yuand 1.0.0

package/lib/components/Table/types.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="react" />
+import type { FormInstance, TableColumnType, TableProps, FormProps } from "antd";
+import type { HttpMethod } from "../../fetch";
+import type { UseBoundStore, StoreApi } from "zustand";
+import type { GetQueryProps } from "../../utils/table";
+type RecordType = Record<string, any>;
+interface SorterType {
+    field?: string;
+    order?: "ascend" | "descend";
+}
+export interface TableState<TData = any> {
+    page: number;
+    size: number;
+    sorter: SorterType;
+    data: TData;
+    search: RecordType | null | undefined;
+    params: any[] | Record<string, any> | null | undefined;
+    setState: (values: Partial<TableState>) => void;
+    ready: boolean;
+}
+type UseStoreType<TData> = UseBoundStore<StoreApi<TableState<TData>>>;
+export interface TableInstance<TData = any> {
+    useStore: UseStoreType<TData>;
+    queryKey: any[];
+    run: () => void;
+    clear: () => void;
+    refresh: () => void;
+    reset: () => void;
+    sortOrder: (key: string) => any;
+    update: () => void;
+    resetStore: () => void;
+    form?: FormInstance;
+}
+interface FormOptions extends Omit<FormProps, "form" | "title" | "children"> {
+    title?: React.ReactNode;
+    /** @deprecated 此属性已废弃，请使用新的formItem属性代替 */
+    items?: React.ReactNode | React.ReactNode[];
+    formItem?: React.ReactNode | React.ReactNode[];
+    extra?: React.ReactNode;
+    right?: React.ReactNode;
+    handleValues?: (values: Record<string, any>) => any;
+    reset?: boolean;
+    onResetBefore?: () => void | boolean;
+    dataForm?: FormProps;
+}
+export interface ProTableProps<Tdata = any> extends Omit<TableProps<Tdata>, "columns"> {
+    classNames?: {
+        root?: string;
+        form?: string;
+        table?: string;
+    };
+    styles?: {
+        root?: React.CSSProperties;
+        form?: React.CSSProperties;
+        table?: React.CSSProperties;
+        toolbar?: React.CSSProperties;
+    };
+    /** API 请求配置 */
+    request: {
+        /** 请求地址方法 */
+        url?: string;
+        method?: HttpMethod;
+        /** 请求参数 */
+        params?: Record<string, any>;
+        onBefore?: () => any;
+        onSuccess?: (data: any) => any;
+    };
+    url: string;
+    table: TableInstance<Tdata> | null;
+    locale?: Record<string, any>;
+    dataKey?: string;
+    totalKey?: string;
+    manual?: boolean;
+    nostyle?: boolean;
+    params?: RecordType;
+    columns: ((data: Tdata) => TableColumnType<unknown>[]) | TableColumnType<unknown>[];
+    form?: FormOptions;
+    alert?: React.ReactNode | ((data: Tdata) => React.ReactNode);
+    toolbar?: React.ReactNode;
+    pageSizeOptions?: number[];
+    onBefore?: () => void;
+    onSuccess?: (data: Tdata) => any;
+    pagination?: {
+        showQuickJumper?: boolean;
+        showSizeChanger?: boolean;
+        hideOnSinglePage?: boolean;
+    };
+    loadingDelay?: number;
+    method?: HttpMethod;
+    useData?: boolean;
+}
+export interface UseTableProps {
+    page?: number;
+    size?: number;
+    sorter?: SorterType;
+}
+export interface ProTableConfigOptions {
+    getQuery?: (data: GetQueryProps) => Record<string, unknown>;
+    pageSizeOptions?: number[];
+}
+export {};

package/lib/components/Table/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/Table/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/components/Table/useTable.d.ts

@@ -0,0 +1,3 @@
+import type { UseTableProps, TableInstance } from "./types";
+declare const useTable: (options?: UseTableProps) => TableInstance<any>[];
+export default useTable;

package/lib/components/Table/useTable.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/Table/useTable.ts
+var useTable_exports = {};
+__export(useTable_exports, {
+  default: () => useTable_default
+});
+module.exports = __toCommonJS(useTable_exports);
+var import_antd = require("antd");
+var import_react = require("react");
+var import_zustand = require("zustand");
+var useTable = (options = {}) => {
+  const [_, update] = (0, import_react.useState)(0);
+  const [form] = import_antd.Form.useForm();
+  const tableRef = (0, import_react.useRef)(null);
+  if (!tableRef.current) {
+    const initState = {
+      page: options.page ?? 1,
+      size: options.size ?? 10,
+      sorter: options.sorter ?? {},
+      search: {},
+      params: {},
+      data: {},
+      ready: false
+    };
+    const useStore = (0, import_zustand.create)((set) => ({
+      ...initState,
+      setState(values = {}) {
+        set(values);
+      }
+    }));
+    tableRef.current = {
+      form,
+      useStore,
+      queryKey: [],
+      run() {
+      },
+      clear: () => {
+      },
+      refresh: () => {
+      },
+      reset: () => {
+      },
+      sortOrder(key) {
+        const sorter = useStore.getState().sorter;
+        if (sorter && sorter.field === key) {
+          return sorter.order;
+        }
+        return null;
+      },
+      resetStore() {
+        useStore.getState().setState(initState);
+      },
+      update: () => update((v) => v + 1)
+    };
+    useStore.subscribe((state, prevState) => {
+      var _a, _b, _c, _d;
+      const sorterChanged = state.sorter !== prevState.sorter;
+      const orderChanged = ((_a = state.sorter) == null ? void 0 : _a.order) !== ((_b = prevState.sorter) == null ? void 0 : _b.order);
+      const fieldChanged = ((_c = state.sorter) == null ? void 0 : _c.field) !== ((_d = prevState.sorter) == null ? void 0 : _d.field);
+      if (sorterChanged && (orderChanged || fieldChanged)) {
+        tableRef.current = { ...tableRef.current };
+        update((v) => v + 1);
+      }
+    });
+  }
+  return [tableRef.current];
+};
+var useTable_default = useTable;

package/lib/components/TableConfig/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+interface Props {
+    children: React.ReactNode;
+    lang?: Record<string, string>;
+}
+export declare const I18nContext: import("react").Context<{
+    lang?: Record<string, any>;
+}>;
+export declare const t: (key: string, i18n: Record<string, any>) => any;
+export default function TableConfig({ children, lang }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/components/TableConfig/index.js

@@ -0,0 +1,55 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/TableConfig/index.tsx
+var TableConfig_exports = {};
+__export(TableConfig_exports, {
+  I18nContext: () => I18nContext,
+  default: () => TableConfig,
+  t: () => t
+});
+module.exports = __toCommonJS(TableConfig_exports);
+var import_react = require("react");
+var import_zh_CN = __toESM(require("../../../lang/zh_CN.json"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var I18nContext = (0, import_react.createContext)({});
+var t = (key, i18n) => {
+  if (!i18n)
+    return key;
+  return i18n[key] || key;
+};
+function TableConfig({ children, lang = import_zh_CN.default }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(I18nContext.Provider, { value: {
+    lang
+  }, children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  I18nContext,
+  t
+});

package/lib/components/TableUseFetch/index.d.ts

@@ -0,0 +1,12 @@
+import type { ProTableProps, ProTableConfigOptions } from "./types";
+import "./style.css";
+declare const ProTable: {
+    <T extends Record<string, any>>(props: ProTableProps<T>): import("react/jsx-runtime").JSX.Element;
+    useTable: (options?: import("./types").UseTableProps) => import("./types").TableRef[];
+    getQuery(options: any): Record<string, unknown>;
+    formatDate: (key: string, data: Record<string, any>, format?: string) => Record<string, any>;
+    removeEmpty: (data: Record<string, any>) => Record<string, any>;
+    pageSizeOptions: number[];
+    config(options: ProTableConfigOptions): void;
+};
+export default ProTable;

package/lib/components/TableUseFetch/index.js

@@ -0,0 +1,303 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/TableUseFetch/index.tsx
+var TableUseFetch_exports = {};
+__export(TableUseFetch_exports, {
+  default: () => TableUseFetch_default
+});
+module.exports = __toCommonJS(TableUseFetch_exports);
+var import_shallow = require("zustand/react/shallow");
+var import_react = require("react");
+var import_antd = require("antd");
+var import_table = require("../../utils/table");
+var import_util = require("../../utils/util");
+var import_useFetch = __toESM(require("../../hooks/useFetch"));
+var import_useX = __toESM(require("../../hooks/useX"));
+var import_useTable = __toESM(require("./useTable"));
+var import_style = require("./style.css");
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultClassNames = {
+  root: "main-container",
+  form: "search-form",
+  table: "main-table"
+};
+var defaultStyles = {
+  root: {},
+  form: {
+    display: "flex",
+    justifyContent: "space-between"
+  },
+  table: {},
+  toolbar: {
+    marginBottom: 15
+  }
+};
+var ProTable = (props) => {
+  const {
+    classNames = defaultClassNames,
+    styles = defaultStyles,
+    table,
+    locale,
+    dataKey = "data",
+    totalKey = "total",
+    manual = false,
+    nostyle,
+    request = {},
+    columns,
+    form = {},
+    alert,
+    toolbar = null,
+    pageSizeOptions = [10, 20, 50, 100],
+    pagination,
+    loadingDelay = 300,
+    scroll,
+    ...prop
+  } = props;
+  const {
+    title: formTitle,
+    extra: formExtra,
+    right: formRight,
+    formItem,
+    items,
+    reset: formReset,
+    dataForm,
+    handleValues: formHandleValues,
+    onResetBefore: formOnResetBefore,
+    ...otherFormProps
+  } = form;
+  const formItems = formItem || items;
+  const { data, page, size, sorter, search, ready, setState } = table.useStore(
+    (0, import_shallow.useShallow)((state) => {
+      return {
+        data: state.data,
+        page: state.page,
+        size: state.size,
+        sorter: state.sorter,
+        search: state.search,
+        ready: state.ready,
+        setState: state.setState
+      };
+    })
+  );
+  const { loading } = (0, import_useFetch.default)(request.url, {
+    method: request.method,
+    onBefore: request.onBefore,
+    json: ProTable.getQuery({
+      page,
+      size,
+      sorter,
+      search,
+      params: request.params
+    }),
+    ready,
+    onFinally: () => {
+      setState({
+        ready: false
+      });
+    },
+    onSuccess(data2) {
+      setState({
+        data: data2
+      });
+    },
+    loadingDelay
+  });
+  const { dataSource, total, column, renderAlert } = (0, import_react.useMemo)(() => {
+    return {
+      column: typeof columns === "function" ? columns(data) : columns,
+      dataSource: (0, import_table.getDataSource)(data, dataKey),
+      renderAlert: typeof alert === "function" ? alert(data) : alert,
+      total: (0, import_table.getTotal)(totalKey, data)
+    };
+  }, [columns, data, dataKey, totalKey]);
+  const onSearch = () => {
+    if (formItems) {
+      table.form.submit();
+    } else {
+      setState({
+        ready: true
+      });
+    }
+  };
+  const onReset = () => {
+    setState({
+      size: 10,
+      sorter: {}
+    });
+    if (formItems) {
+      if ((formOnResetBefore == null ? void 0 : formOnResetBefore()) === false)
+        return;
+      table.form.resetFields();
+      if (formReset === void 0 || formReset === true) {
+        table.form.submit();
+      }
+    }
+  };
+  if (table) {
+    table.run = onSearch;
+    table.reset = () => {
+      if (formItems) {
+        onReset();
+      }
+    };
+  }
+  (0, import_react.useEffect)(() => {
+    if (manual)
+      return;
+    if (formItems) {
+      table.form.submit();
+    } else {
+      setState({
+        ready: true
+      });
+    }
+  }, [table]);
+  const onFinish = (values) => {
+    if (formHandleValues) {
+      values = formHandleValues(values);
+    }
+    if (!values)
+      return;
+    setState({
+      page: 1,
+      search: values,
+      ready: true
+    });
+  };
+  const tableChange = (pagination2, sorter2) => {
+    setState({
+      page: pagination2.current,
+      size: pagination2.pageSize,
+      sorter: sorter2,
+      ready: true
+    });
+  };
+  const x = (0, import_useX.default)(column);
+  const y = scroll == null ? void 0 : scroll.y;
+  const renderTable = () => {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_antd.Table,
+      {
+        columns: column,
+        loading,
+        scroll: { x, y },
+        locale,
+        onChange: (p, _, sorter2) => tableChange(p, sorter2),
+        pagination: {
+          current: page,
+          pageSize: size,
+          showQuickJumper: pagination ? pagination.showQuickJumper : true,
+          showSizeChanger: pagination ? pagination.showSizeChanger : true,
+          hideOnSinglePage: pagination ? pagination.hideOnSinglePage : false,
+          pageSizeOptions,
+          total,
+          showTotal(total2) {
+            return `共 ${total2} 条记录`;
+          }
+        },
+        dataSource,
+        ...prop
+      }
+    );
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      className: (classNames == null ? void 0 : classNames.root) ?? defaultClassNames.root,
+      style: styles.root,
+      children: [
+        !!formItems && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "div",
+          {
+            className: (classNames == null ? void 0 : classNames.form) ?? defaultClassNames.form,
+            style: styles.form,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+                import_antd.Form,
+                {
+                  form: table.form,
+                  layout: "inline",
+                  onFinish,
+                  ...otherFormProps,
+                  children: [
+                    formTitle && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_antd.Form.Item, { children: formTitle }),
+                    formItems,
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_antd.Form.Item, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_antd.Space, { children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_antd.Button, { type: "primary", loading, htmlType: "submit", children: "查询" }),
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_antd.Button, { onClick: onReset, disabled: loading, children: "重置" }),
+                      formExtra
+                    ] }) })
+                  ]
+                }
+              ),
+              formRight
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "div",
+          {
+            className: (classNames == null ? void 0 : classNames.table) ?? defaultClassNames.table,
+            style: styles.table,
+            children: [
+              toolbar && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: styles.toolbar, children: toolbar }),
+              renderAlert,
+              !!dataForm ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_antd.Form, { ...dataForm, children: renderTable() }) : renderTable()
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+ProTable.useTable = import_useTable.default;
+ProTable.getQuery = (options) => {
+  const { page, size, sorter, search, params } = options;
+  return (0, import_table.getQuery)({
+    page,
+    size,
+    sorter,
+    search,
+    params
+  });
+};
+ProTable.formatDate = import_table.formatDate;
+ProTable.removeEmpty = import_table.removeEmpty;
+ProTable.pageSizeOptions = [10, 20, 50, 100];
+ProTable.config = (options) => {
+  if (!options || !(0, import_util.isObject)(options))
+    return;
+  if (options.getQuery) {
+    ProTable.getQuery = options.getQuery;
+  }
+  if (options.pageSizeOptions) {
+    ProTable.pageSizeOptions = options.pageSizeOptions;
+  }
+};
+var TableUseFetch_default = ProTable;

package/lib/components/TableUseFetch/style.css

@@ -0,0 +1,3 @@
+.search-form .ant-form-item {
+    margin-bottom: 20px!important;
+}

package/lib/components/TableUseFetch/types.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="react" />
+import type { FormInstance, TableColumnType, TableProps, FormProps } from "antd";
+import type { HttpMethod } from "../../fetch";
+import type { UseBoundStore, StoreApi } from "zustand";
+import type { GetQueryProps } from "../../utils/table";
+type RecordType = Record<string, any>;
+interface SorterType {
+    field?: string;
+    order?: "ascend" | "descend";
+}
+export interface TableState<TData = any> {
+    page: number;
+    size: number;
+    sorter: SorterType;
+    data: TData;
+    search: RecordType | null | undefined;
+    params: any[] | Record<string, any> | null | undefined;
+    setState: (values: Partial<TableState>) => void;
+    ready: boolean;
+}
+type UseStoreType<TData> = UseBoundStore<StoreApi<TableState<TData>>>;
+export interface TableInstance<TData = any> {
+    useStore: UseStoreType<TData>;
+    run: () => void;
+    clear: () => void;
+    refresh: () => void;
+    reset: () => void;
+    sortOrder: (key: string) => any;
+    update: () => void;
+    form?: FormInstance;
+}
+interface FormOptions extends Omit<FormProps, "form" | "title"> {
+    title?: React.ReactNode;
+    /** @deprecated 此属性已废弃，请使用新的formItem属性代替 */
+    items?: React.ReactNode | React.ReactNode[];
+    formItem?: React.ReactNode | React.ReactNode[];
+    extra?: React.ReactNode;
+    right?: React.ReactNode;
+    handleValues?: (values: Record<string, any>) => any;
+    reset?: boolean;
+    onResetBefore?: () => void | boolean;
+    dataForm?: FormProps;
+}
+export interface ProTableProps<Tdata = any> extends Omit<TableProps<Tdata>, "columns"> {
+    classNames?: {
+        root?: string;
+        form?: string;
+        table?: string;
+    };
+    styles?: {
+        root?: React.CSSProperties;
+        form?: React.CSSProperties;
+        table?: React.CSSProperties;
+        toolbar?: React.CSSProperties;
+    };
+    request?: {
+        url?: string;
+        method?: HttpMethod;
+        params?: RecordType;
+        onBefore?: () => any;
+        onSuccess?: (data: Tdata) => any;
+    };
+    table: TableInstance<Tdata> | null;
+    locale?: Record<string, any>;
+    dataKey?: string;
+    totalKey?: string;
+    manual?: boolean;
+    nostyle?: boolean;
+    columns: ((data: Tdata) => TableColumnType<unknown>[]) | TableColumnType<unknown>[];
+    form?: FormOptions;
+    alert?: React.ReactNode | ((data: Tdata) => React.ReactNode);
+    toolbar?: React.ReactNode;
+    pageSizeOptions?: number[];
+    pagination?: {
+        showQuickJumper?: boolean;
+        showSizeChanger?: boolean;
+        hideOnSinglePage?: boolean;
+    };
+    loadingDelay?: number;
+}
+export interface UseTableProps {
+    page?: number;
+    size?: number;
+    sorter?: SorterType;
+}
+export interface TableRef {
+    form: FormInstance;
+    useStore: UseStoreType<any>;
+    run: () => void;
+    clear: () => void;
+    refresh: () => void;
+    reset: () => void;
+    sortOrder: (key: string) => "ascend" | "descend" | null;
+    update: () => void;
+}
+export interface ProTableConfigOptions {
+    getQuery?: (data: GetQueryProps) => Record<string, unknown>;
+    pageSizeOptions?: number[];
+}
+export {};