@lxlib/seed/esm5/st/st.interfaces.js

This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 9.1.1.

/**
 * @fileoverview added by tsickle
 * Generated from: st.interfaces.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @record
 */
export function STWidthMode() { }
if (false) {
    /**
     * 宽度类型
     * - `default` 默认行为
     * - `strict` 严格模式，即强制按 `width` 指定的宽度呈现，并根据 `strictBehavior` 类型处理
     * @type {?|undefined}
     */
    STWidthMode.prototype.type;
    /**
     * 严格模式的处理行为
     * - `wrap` 强制换行
     * - `truncate` 截短
     * @type {?|undefined}
     */
    STWidthMode.prototype.strictBehavior;
}
/**
 * @record
 */
export function STResetColumnsOption() { }
if (false) {
    /** @type {?|undefined} */
    STResetColumnsOption.prototype.pi;
    /** @type {?|undefined} */
    STResetColumnsOption.prototype.ps;
    /** @type {?|undefined} */
    STResetColumnsOption.prototype.columns;
    /**
     * Whether to trigger a data load, default: `true`
     * @type {?|undefined}
     */
    STResetColumnsOption.prototype.emitReload;
}
/**
 * @record
 */
export function STReq() { }
if (false) {
    /**
     * 分页类型，默认：`page`
     * - `page` 使用 `pi`，`ps` 组合
     * - `skip` 使用 `skip`，`limit` 组合
     * @type {?|undefined}
     */
    STReq.prototype.type;
    /**
     * 额外请求参数，默认自动附加 `pi`、`ps` 至URL
     * - `{ status: 'new' }` => `url?pi=1&ps=10&status=new`
     * @type {?|undefined}
     */
    STReq.prototype.params;
    /**
     * 请求方法，默认：`GET`
     * @type {?|undefined}
     */
    STReq.prototype.method;
    /**
     * 请求体 `body`
     * @type {?|undefined}
     */
    STReq.prototype.body;
    /**
     * 请求体 `Header`
     * @type {?|undefined}
     */
    STReq.prototype.headers;
    /**
     * 重命名参数 `pi`、`ps`，默认：`{ pi: 'pi', ps: 'ps' }`
     * - `{ pi: 'Page' }` => `pi` 会被替换成 Page
     * @type {?|undefined}
     */
    STReq.prototype.reName;
    /**
     * 是否将请求所有参数数据都放入 `body` 当中（`url` 地址本身参数除外），仅当 `method: 'POST'` 时有效，默认：`false`
     * @type {?|undefined}
     */
    STReq.prototype.allInBody;
    /**
     * 是否延迟加载数据，即渲染结束后不会主动发起请求，默认：`false`
     * @type {?|undefined}
     */
    STReq.prototype.lazyLoad;
    /**
     * 请求前数据处理
     * @type {?|undefined}
     */
    STReq.prototype.process;
}
/**
 * @record
 */
export function STRequestOptions() { }
if (false) {
    /** @type {?|undefined} */
    STRequestOptions.prototype.body;
    /** @type {?|undefined} */
    STRequestOptions.prototype.headers;
    /** @type {?|undefined} */
    STRequestOptions.prototype.params;
    /** @type {?|undefined} */
    STRequestOptions.prototype.observe;
    /** @type {?|undefined} */
    STRequestOptions.prototype.reportProgress;
    /** @type {?|undefined} */
    STRequestOptions.prototype.responseType;
    /** @type {?|undefined} */
    STRequestOptions.prototype.withCredentials;
}
/**
 * @record
 */
export function STLoadOptions() { }
if (false) {
    /**
     * 是否合并，默认：`false`
     * @type {?|undefined}
     */
    STLoadOptions.prototype.merge;
    /**
     * 是否跳转至顶部，若不指定由 `page.toTop` 来决定
     * @type {?|undefined}
     */
    STLoadOptions.prototype.toTop;
}
/**
 * @record
 */
export function STRes() { }
if (false) {
    /**
     * 重命名返回参数 `total`、`list`
     * - `{ total: 'Total' }` => Total 会被当作 `total`
     * @type {?|undefined}
     */
    STRes.prototype.reName;
    /**
     * 数据预处理
     * @type {?|undefined}
     */
    STRes.prototype.process;
}
/**
 * @record
 */
export function STPage() { }
if (false) {
    /**
     * 前端分页，当 `data` 为`any[]` 或 `Observable<any[]>` 有效，默认：`true`
     * - `true` 由 `st` 根据 `data` 长度受控分页，包括：排序、过滤等
     * - `false` 由用户通过 `total` 和 `data` 参数受控分页，并维护 `(change)` 当分页变更时重新加载数据
     * @type {?|undefined}
     */
    STPage.prototype.front;
    /**
     * 后端分页是否采用`0`基索引，只在`data`类型为`string`时有效，默认：`false`
     * @type {?|undefined}
     */
    STPage.prototype.zeroIndexed;
    /**
     * 指定分页显示的位置，默认：`bottom`
     * @type {?|undefined}
     */
    STPage.prototype.position;
    /**
     * 指定分页分页方向，默认：`right`
     * @type {?|undefined}
     */
    STPage.prototype.placement;
    /**
     * 是否显示分页器，默认：`true`
     * @type {?|undefined}
     */
    STPage.prototype.show;
    /**
     * 是否显示分页器中改变页数，默认：`false`
     * @type {?|undefined}
     */
    STPage.prototype.showSize;
    /**
     * 分页器中每页显示条目数下拉框值，默认：`[10, 20, 30, 40, 50]`
     * @type {?|undefined}
     */
    STPage.prototype.pageSizes;
    /**
     * 是否显示分页器中快速跳转，默认：`false`
     * @type {?|undefined}
     */
    STPage.prototype.showQuickJumper;
    /**
     * 是否显示总数据量
     * - `boolean` 类型显示与否，默认模板：`共 {{total}} 条`
     * - `string` 自定义模板，模板变量：
     *  - `{{total}}` 表示数据总量
     *  - `{{range[0]}}` 表示当前页开始数量值
     *  - `{{range[1]}}` 表示当前页结束数量值
     * @type {?|undefined}
     */
    STPage.prototype.total;
    /**
     * 切换分页时返回顶部，默认：`true`
     * @type {?|undefined}
     */
    STPage.prototype.toTop;
    /**
     * 返回顶部偏移值，默认：`100`
     * @type {?|undefined}
     */
    STPage.prototype.toTopOffset;
}
/**
 * 数据源
 * @record
 */
export function STData() { }
if (false) {
    /**
     * 选择框或单选框状态值
     * @type {?|undefined}
     */
    STData.prototype.checked;
    /**
     * 选择框或单选框 `disabled` 值
     * @type {?|undefined}
     */
    STData.prototype.disabled;
    /**
     * 是否展开状态
     * @type {?|undefined}
     */
    STData.prototype.expand;
    /**
     * 是否显示展开按钮
     * @type {?|undefined}
     */
    STData.prototype.showExpand;
    /* Skipping unhandled member: [key: string]: any;*/
}
/**
 * 列描述
 * @record
 */
export function STColumn() { }
if (false) {
    /**
     * 用于定义数据源主键，例如：`STStatistical`
     * @type {?|undefined}
     */
    STColumn.prototype.key;
    /**
     * 列标题
     * @type {?|undefined}
     */
    STColumn.prototype.title;
    /**
     * 列数据在数据项中对应的 key，支持 `a.b.c` 的嵌套写法，例如：
     * - `id`
     * - `price.market`
     * - `[ 'price', 'market' ]`
     * @type {?|undefined}
     */
    STColumn.prototype.index;
    /**
     * 类型
     * - `no` 行号，计算规则：`index + noIndex`
     * - `checkbox` 多选
     * - `radio` 单选
     * - `link` 链接，务必指定 `click`
     * - `badge` [徽标](https://ng.ant.design/components/badge/zh)，务必指定 `badge` 参数配置徽标对应值
     * - `tag` [标签](https://ng.ant.design/components/tag/zh)，务必指定 `tag` 参数配置标签对应值
     * - `img` 图片且居中(若 `className` 存在则优先)
     * - `number` 数字且居右(若 `className` 存在则优先)
     * - `currency` 货币且居右(若 `className` 存在则优先)
     * - `date` 日期格式且居中(若 `className` 存在则优先)，使用 `dateFormat` 自定义格式
     * - `yn` 将`boolean`类型徽章化 [document](https://ng-alain.com/docs/data-render#yn)
     * @type {?|undefined}
     */
    STColumn.prototype.type;
    /**
     * 链接回调，若返回一个字符串表示导航URL会自动触发 `router.navigateByUrl`
     * @type {?|undefined}
     */
    STColumn.prototype.click;
    /**
     * 按钮组
     * @type {?|undefined}
     */
    STColumn.prototype.buttons;
    /**
     * 自定义渲染ID
     * \@example
     * <ng-template st-row="custom" let-item let-index="index" let-column="column">
     *  {{ c.title }}
     * </ng-template>
     * @type {?|undefined}
     */
    STColumn.prototype.render;
    /**
     * 标题自定义渲染ID
     * \@example
     * <ng-template st-row="custom" type="title" let-c>
     *  {{ item | json }}
     * </ng-template>
     * @type {?|undefined}
     */
    STColumn.prototype.renderTitle;
    /**
     * 列宽（数字型表示 `px` 值），例如：`100`、`10%`、`100px`
     *
     * **注意：** 若固定列必须是数字
     * @type {?|undefined}
     */
    STColumn.prototype.width;
    /**
     * 排序配置项，远程数据配置**优先**规则：
     * - `true` 表示允许排序
     * - `string` 表示远程数据排序相对应 `key` 值
     * @type {?|undefined}
     */
    STColumn.prototype.sort;
    /**
     * 过滤配置项
     * @type {?|undefined}
     */
    STColumn.prototype.filter;
    /**
     * 格式化列值
     * @type {?|undefined}
     */
    STColumn.prototype.format;
    /**
     * 自定义全/反选选择项
     * @type {?|undefined}
     */
    STColumn.prototype.selections;
    /**
     * 列 `class` 属性值（注：无须 `.` 点）多个用空格隔开，例如：
     * - `text-center` 居中
     * - `text-right` 居右
     * - `text-success` 成功色
     * - `text-danger` 异常色
     * @type {?|undefined}
     */
    STColumn.prototype.className;
    /**
     * 合并列
     * @type {?|undefined}
     */
    STColumn.prototype.colSpan;
    /**
     * 数字格式，`type=number` 有效
     * @type {?|undefined}
     */
    STColumn.prototype.numberDigits;
    /**
     * 日期格式，`type=date` 有效，（默认：`yyyy-MM-dd HH:mm`）
     * @type {?|undefined}
     */
    STColumn.prototype.dateFormat;
    /**
     * 当 `type=yn` 有效
     * @type {?|undefined}
     */
    STColumn.prototype.yn;
    /**
     * 是否允许导出，默认 `true`
     * @type {?|undefined}
     */
    STColumn.prototype.exported;
    /**
     * 权限，等同 [ACLCanType](https://ng-alain.com/acl/getting-started/#ACLCanType) 参数值
     * @type {?|undefined}
     */
    STColumn.prototype.acl;
    /**
     * 当不存在数据时以默认值替代
     * @type {?|undefined}
     */
    STColumn.prototype.default;
    /**
     * 固定前后列，当指定时务必指定 `width` 否则视为无效，有若干 **注意：** 项：
     *
     * - 若列头与内容不对齐或出现列重复，请指定列的宽度 `width`
     * - 建议指定 `scroll.x` 为大于表格宽度的固定值或百分比。注意，且非固定列宽度之和不要超过 `scroll.x`
     * @type {?|undefined}
     */
    STColumn.prototype.fixed;
    /**
     * 徽标配置项
     * @type {?|undefined}
     */
    STColumn.prototype.badge;
    /**
     * 标签配置项
     * @type {?|undefined}
     */
    STColumn.prototype.tag;
    /**
     * 行号索引，默认：`1`
     * - 计算规则为：`index + noIndex`
     * - 支持自定义方法
     * @type {?|undefined}
     */
    STColumn.prototype.noIndex;
    /**
     * 条件表达式
     * - 仅赋值 `columns` 时执行一次
     * - 可调用 `resetColumns()` 再一次触发
     * @type {?|undefined}
     */
    STColumn.prototype.iif;
    /**
     * 统计
     * @type {?|undefined}
     */
    STColumn.prototype.statistical;
    /**
     * @ignore internal property
     * @type {?|undefined}
     */
    STColumn.prototype._sort;
    /* Skipping unhandled member: [key: string]: any;*/
}
/**
 * @record
 */
export function STColumnTitle() { }
if (false) {
    /**
     * Text of header, can be choose one of `text` or `i18n`
     * @type {?|undefined}
     */
    STColumnTitle.prototype.text;
    /**
     * I18n key of header, can be choose one of `text` or `i18n`
     * @type {?|undefined}
     */
    STColumnTitle.prototype.i18n;
    /**
     * Optional information of header
     * @type {?|undefined}
     */
    STColumnTitle.prototype.optional;
    /**
     * Optional help of header
     * @type {?|undefined}
     */
    STColumnTitle.prototype.optionalHelp;
    /* Skipping unhandled member: [key: string]: any;*/
}
/**
 * @record
 */
export function STStatistical() { }
if (false) {
    /** @type {?} */
    STStatistical.prototype.type;
    /**
     * 保留小数位数，默认：`2`
     * @type {?|undefined}
     */
    STStatistical.prototype.digits;
    /**
     * 是否需要货币格式化，默认以下情况为 `true`
     * - `type` 为 `STStatisticalFn`、 `sum`、`average`、`max`、`min`
     * @type {?|undefined}
     */
    STStatistical.prototype.currency;
}
/**
 * @record
 */
export function STStatisticalResults() { }
/**
 * @record
 */
export function STStatisticalResult() { }
if (false) {
    /** @type {?} */
    STStatisticalResult.prototype.value;
    /** @type {?|undefined} */
    STStatisticalResult.prototype.text;
}
/**
 * @record
 */
export function STColumnSort() { }
if (false) {
    /**
     * 排序的默认受控属性
     * @type {?|undefined}
     */
    STColumnSort.prototype.default;
    /**
     * 本地数据的排序函数，使用一个函数(参考 [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) 的 compareFunction)
     * - `null` 忽略本地排序，但保持排序功能
     * @type {?|undefined}
     */
    STColumnSort.prototype.compare;
    /**
     * 远程数据的排序时后端相对应的KEY，默认使用 `index` 属性
     * - 若 `multiSort: false` 时：`key: 'name' => ?name=1&pi=1`
     * - 若 `multiSort: true` 允许多个排序 key 存在，或使用 `STMultiSort` 指定多列排序key合并规则
     * @type {?|undefined}
     */
    STColumnSort.prototype.key;
    /**
     * 远程数据的排序时后端相对应的VALUE
     * - `{ ascend: '0', descend: '1' }` 结果 `?name=1&pi=1`
     * - `{ ascend: 'asc', descend: 'desc' }` 结果 `?name=desc&pi=1`
     * @type {?|undefined}
     */
    STColumnSort.prototype.reName;
}
/**
 * @record
 */
export function STSortMap() { }
if (false) {
    /**
     * 是否启用排序
     * @type {?|undefined}
     */
    STSortMap.prototype.enabled;
    /* Skipping unhandled member: [key: string]: any;*/
}
/**
 * @record
 */
export function STColumnFilter() { }
if (false) {
    /**
     * 搜索方式
     * - `defualt` 默认形式
     * - `keyword` 文本框形式
     * @type {?|undefined}
     */
    STColumnFilter.prototype.type;
    /**
     * 表头的筛选菜单项，至少一项才会生效
     * - 当 `type='keyword'` 时可为空
     * @type {?|undefined}
     */
    STColumnFilter.prototype.menus;
    /**
     * 本地数据的筛选函数
     * @type {?|undefined}
     */
    STColumnFilter.prototype.fn;
    /**
     * 标识数据是否已过滤，筛选图标会高亮
     * @type {?|undefined}
     */
    STColumnFilter.prototype.default;
    /**
     * 自定义 filter 图标
     * - 当 `type='default'` 默认 `filter`
     * - 当 `type='keyword'` 默认 `search`
     * @type {?|undefined}
     */
    STColumnFilter.prototype.icon;
    /**
     * 确认按钮文本，默认 `确认`
     * @type {?|undefined}
     */
    STColumnFilter.prototype.confirmText;
    /**
     * 清除按钮文本，默认 `重置`
     * @type {?|undefined}
     */
    STColumnFilter.prototype.clearText;
    /**
     * 是否多选，默认 `true`
     * @type {?|undefined}
     */
    STColumnFilter.prototype.multiple;
    /**
     * 远程数据的过滤时后端相对应的KEY，默认使用 `index` 属性
     * `key: 'name'` 结果 `?name=1&pi=1`
     * @type {?|undefined}
     */
    STColumnFilter.prototype.key;
    /**
     * 远程数据的过滤时后端相对应的VALUE
     * - 默认当 `multiple: true` 时以英文逗号拼接的字符串
     * \@return 返回为 Object 对象
     * @type {?|undefined}
     */
    STColumnFilter.prototype.reName;
}
/**
 * @record
 */
export function STColumnFilterMenu() { }
if (false) {
    /**
     * 文本
     * - 当 `type: 'keyword'` 时表示 `placeholder`
     * @type {?|undefined}
     */
    STColumnFilterMenu.prototype.text;
    /**
     * 值
     * @type {?|undefined}
     */
    STColumnFilterMenu.prototype.value;
    /**
     * 是否选中
     * @type {?|undefined}
     */
    STColumnFilterMenu.prototype.checked;
    /**
     * 权限，等同 [ACLCanType](https://ng-alain.com/acl/getting-started/#ACLCanType) 参数值
     * @type {?|undefined}
     */
    STColumnFilterMenu.prototype.acl;
    /* Skipping unhandled member: [key: string]: any;*/
}
/**
 * @record
 */
export function STColumnSelection() { }
if (false) {
    /**
     * 选择项显示的文字
     * @type {?}
     */
    STColumnSelection.prototype.text;
    /**
     * 选择项点击回调，允许对参数 `data.checked` 进行操作
     * @type {?}
     */
    STColumnSelection.prototype.select;
    /**
     * 权限，等同 `can()` 参数值
     * @type {?|undefined}
     */
    STColumnSelection.prototype.acl;
}
/**
 * 当 `type=yn` 有效
 * @record
 */
export function STColumnYn() { }
if (false) {
    /**
     * 真值条件，（默认：`true`）
     * @type {?|undefined}
     */
    STColumnYn.prototype.truth;
    /**
     * 徽章 `true` 时文本，（默认：`是`）
     * @type {?|undefined}
     */
    STColumnYn.prototype.yes;
    /**
     * 徽章 `false` 时文本，（默认：`否`）
     * @type {?|undefined}
     */
    STColumnYn.prototype.no;
    /**
     * 徽章显示风格
     * - `full` 图标和文本
     * - `icon` 图标
     * - `text` 文本
     * @type {?|undefined}
     */
    STColumnYn.prototype.mode;
}
/**
 * @record
 */
export function STIcon() { }
if (false) {
    /**
     * 图标类型
     * @type {?}
     */
    STIcon.prototype.type;
    /**
     * 图标主题风格，默认：`outline`
     * @type {?|undefined}
     */
    STIcon.prototype.theme;
    /**
     * 是否有旋转动画，默认：`false`
     * @type {?|undefined}
     */
    STIcon.prototype.spin;
    /**
     * 仅适用双色图标，设置双色图标的主要颜色，仅对当前 icon 生效
     * @type {?|undefined}
     */
    STIcon.prototype.twoToneColor;
    /**
     * 指定来自 IconFont 的图标类型
     * @type {?|undefined}
     */
    STIcon.prototype.iconfont;
}
/**
 * 按钮配置
 * @record
 */
export function STColumnButton() { }
if (false) {
    /**
     * 文本
     * @type {?|undefined}
     */
    STColumnButton.prototype.text;
    /**
     * 文本 i18n
     * @type {?|undefined}
     */
    STColumnButton.prototype.i18n;
    /**
     * 图标
     * @type {?|undefined}
     */
    STColumnButton.prototype.icon;
    /**
     * 按钮类型
     * - `none` 无任何互动
     * - `del` 删除，默认开启 `pop: true`
     * - `modal` 对话框，需要指定 `component` 才会生效
     * - `static` 静态对话框，需要指定 `component` 才会生效
     * - `drawer` 抽屉，需要指定 `component` 才会生效
     * - `link` 链接，当 `click` 返回字符串时自动调用 `navigateByUrl` 导航
     * - `divider` 分割线
     * @type {?|undefined}
     */
    STColumnButton.prototype.type;
    /**
     * 点击回调
     * - Function
     *  - `type=modal` 只会在当有传回值时才会触发回调
     * - reload：重新刷新当前页
     * - load：重新加载数据，并重置页码为：`1`
     *
     * \@todo Bad parameter design
     * @type {?|undefined}
     */
    STColumnButton.prototype.click;
    /**
     * 气泡确认框参数，若 `string` 类型表示标题
     * @type {?|undefined}
     */
    STColumnButton.prototype.pop;
    /**
     * 对话框参数
     * @type {?|undefined}
     */
    STColumnButton.prototype.modal;
    /**
     * 抽屉参数
     * @type {?|undefined}
     */
    STColumnButton.prototype.drawer;
    /**
     * 下拉菜单，当存在时以 `dropdown` 形式渲染
     * - 只支持一级
     * @type {?|undefined}
     */
    STColumnButton.prototype.children;
    /**
     * 权限，等同 [ACLCanType](https://ng-alain.com/acl/getting-started/#ACLCanType) 参数值
     * @type {?|undefined}
     */
    STColumnButton.prototype.acl;
    /**
     * Conditional expression
     *
     * \@todo Bad parameter design
     * @type {?|undefined}
     */
    STColumnButton.prototype.iif;
    /**
     * Conditional expression rendering behavior, can be set to `hide` (default) or `disabled`
     * @type {?|undefined}
     */
    STColumnButton.prototype.iifBehavior;
    /** @type {?|undefined} */
    STColumnButton.prototype.tooltip;
    /* Skipping unhandled member: [key: string]: any;*/
}
/**
 * @record
 */
export function STColumnButtonOK() { }
if (false) {
    /** @type {?} */
    STColumnButtonOK.prototype.record;
    /**
     * Modal or drawer return value when trigger confirm.
     * @type {?|undefined}
     */
    STColumnButtonOK.prototype.ret;
    /** @type {?|undefined} */
    STColumnButtonOK.prototype.instance;
    /** @type {?} */
    STColumnButtonOK.prototype.event;
}
/**
 * @record
 */
export function STColumnButtonModal() { }
if (false) {
    /**
     * 对话框组件对象，务必在 `entryComponents` 注册
     * @type {?|undefined}
     */
    STColumnButtonModal.prototype.component;
    /**
     * 对话框参数
     * @type {?|undefined}
     */
    STColumnButtonModal.prototype.params;
    /**
     * 对话框目标组件的接收参数名，默认：`record`
     * @type {?|undefined}
     */
    STColumnButtonModal.prototype.paramsName;
}
/**
 * @record
 */
export function STColumnButtonModalConfig() { }
if (false) {
    /**
     * 指定模态框目标组件的接收参数名，默认：`record`
     * @type {?|undefined}
     */
    STColumnButtonModalConfig.prototype.paramsName;
    /**
     * 大小；例如：lg、600，默认：`lg`
     * @type {?|undefined}
     */
    STColumnButtonModalConfig.prototype.size;
    /**
     * 对话框 [ModalOptions](https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/components/modal/modal-types.ts) 参数
     * @type {?|undefined}
     */
    STColumnButtonModalConfig.prototype.modalOptions;
    /**
     * 是否精准（默认：`true`），若返回值非空值（`null`或`undefined`）视为成功，否则视为错误
     * @type {?|undefined}
     */
    STColumnButtonModalConfig.prototype.exact;
}
/**
 * @record
 */
export function STColumnButtonDrawer() { }
if (false) {
    /**
     * 标题
     * @type {?|undefined}
     */
    STColumnButtonDrawer.prototype.title;
    /**
     * 抽屉组件对象，务必在 `entryComponents` 注册
     * @type {?|undefined}
     */
    STColumnButtonDrawer.prototype.component;
    /**
     * 抽屉参数
     * @type {?|undefined}
     */
    STColumnButtonDrawer.prototype.params;
    /**
     * 抽屉目标组件的接收参数名，默认：`record`
     * @type {?|undefined}
     */
    STColumnButtonDrawer.prototype.paramsName;
}
/**
 * @record
 */
export function STColumnButtonDrawerConfig() { }
if (false) {
    /**
     * 抽屉目标组件的接收参数名，默认：`record`
     * @type {?|undefined}
     */
    STColumnButtonDrawerConfig.prototype.paramsName;
    /**
     * 大小；例如：lg、600，默认：`md`
     *
     * | 类型 | 默认大小 |
     * | --- | ------ |
     * | `sm` | `300` |
     * | `md` | `600` |
     * | `lg` | `900` |
     * | `xl` | `1200` |
     *
     * > 以上值，可通过覆盖相应的LESS参数自行调整
     * @type {?|undefined}
     */
    STColumnButtonDrawerConfig.prototype.size;
    /**
     * 是否包含底部工具条，默认：`true`
     * @type {?|undefined}
     */
    STColumnButtonDrawerConfig.prototype.footer;
    /**
     * 底部工具条高度，默认：`55`
     * @type {?|undefined}
     */
    STColumnButtonDrawerConfig.prototype.footerHeight;
    /**
     * 抽屉 [NzDrawerOptions](https://ng.ant.design/components/drawer/zh#nzdraweroptions) 参数
     * @type {?|undefined}
     */
    STColumnButtonDrawerConfig.prototype.drawerOptions;
}
/**
 * @record
 */
export function STColumnButtonPop() { }
if (false) {
    /**
     * Title of the popover, default: `确认删除吗？`
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.title;
    /**
     * Popover trigger mode, default: `click`
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.trigger;
    /**
     * The position of the popover relative to the target, default: `top`
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.placement;
    /**
     * Class name of the popover card
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.overlayClassName;
    /**
     * Style of the popover card
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.overlayStyle;
    /**
     * Text of the Cancel button
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.cancelText;
    /**
     * Text of the Confirm button
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.okText;
    /**
     * Button `type` of the Confirm button
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.okType;
    /**
     * Customize icon of confirmation
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.icon;
    /**
     * Whether to directly emit `onConfirm` without showing Popconfirm, default: `() => false`
     * @type {?|undefined}
     */
    STColumnButtonPop.prototype.condition;
}
/**
 * @record
 */
export function STReqReNameType() { }
if (false) {
    /** @type {?|undefined} */
    STReqReNameType.prototype.pi;
    /** @type {?|undefined} */
    STReqReNameType.prototype.ps;
    /** @type {?|undefined} */
    STReqReNameType.prototype.skip;
    /** @type {?|undefined} */
    STReqReNameType.prototype.limit;
}
/**
 * @record
 */
export function STResReNameType() { }
if (false) {
    /** @type {?|undefined} */
    STResReNameType.prototype.total;
    /** @type {?|undefined} */
    STResReNameType.prototype.list;
}
/**
 * @record
 */
export function STExportOptions() { }
if (false) {
    /**
     * @ignore internal property
     * @type {?|undefined}
     */
    STExportOptions.prototype._d;
    /**
     * @ignore internal property
     * @type {?|undefined}
     */
    STExportOptions.prototype._c;
    /**
     * 工作溥名
     * @type {?|undefined}
     */
    STExportOptions.prototype.sheetname;
    /**
     * 文件名
     * @type {?|undefined}
     */
    STExportOptions.prototype.filename;
    /**
     * triggers when saveas
     * @type {?|undefined}
     */
    STExportOptions.prototype.callback;
}
/**
 * 单排序规则
 * - 若不指定，则返回：`columnName=ascend|descend`
 * - 若指定，则返回：`sort=columnName.(ascend|descend)`
 * @record
 */
export function STSingleSort() { }
if (false) {
    /**
     * 请求参数名，默认：`sort`
     * @type {?|undefined}
     */
    STSingleSort.prototype.key;
    /**
     * 列名与状态间分隔符，默认：`.`
     * @type {?|undefined}
     */
    STSingleSort.prototype.nameSeparator;
}
/**
 * 多排序相同排序 key 时合并规则
 * @record
 */
export function STMultiSort() { }
if (false) {
    /**
     * 请求参数名，默认：`sort`
     * @type {?|undefined}
     */
    STMultiSort.prototype.key;
    /**
     * 不同属性间分隔符，默认：`-`
     * @type {?|undefined}
     */
    STMultiSort.prototype.separator;
    /**
     * 列名与状态间分隔符，默认：`.`
     * @type {?|undefined}
     */
    STMultiSort.prototype.nameSeparator;
    /**
     * 是否全局多排序模式，默认：`true`
     * - `true` 表示所有 `st` 默认为多排序
     * - `false` 表示需要为每个 `st` 添加 `multiSort` 才会视为多排序模式
     * @type {?|undefined}
     */
    STMultiSort.prototype.global;
    /**
     * 是否保持空值的键名，默认：`true`
     * - `true` 表示不管是否有排序都会发送 `key` 键名
     * - `false` 表示无排序动作时不会发送 `key` 键名
     * @type {?|undefined}
     */
    STMultiSort.prototype.keepEmptyKey;
}
/**
 * 徽标信息
 * @record
 */
export function STColumnBadge() { }
/**
 * @record
 */
export function STColumnBadgeValue() { }
if (false) {
    /**
     * 文本
     * @type {?|undefined}
     */
    STColumnBadgeValue.prototype.text;
    /**
     * 徽标颜色值
     * @type {?|undefined}
     */
    STColumnBadgeValue.prototype.color;
}
/**
 * 标签信息
 * @record
 */
export function STColumnTag() { }
/**
 * @record
 */
export function STColumnTagValue() { }
if (false) {
    /**
     * 文本
     * @type {?|undefined}
     */
    STColumnTagValue.prototype.text;
    /**
     * 颜色值，支持预设和色值
     * - 预设：geekblue,blue,purple,success,red,volcano,orange,gold,lime,green,cyan
     * - 色值：#f50,#ff0
     * @type {?|undefined}
     */
    STColumnTagValue.prototype.color;
}
/**
 * 回调数据
 * @record
 */
export function STChange() { }
if (false) {
    /**
     * 回调类型
     * @type {?}
     */
    STChange.prototype.type;
    /**
     * 当前页码
     * @type {?}
     */
    STChange.prototype.pi;
    /**
     * 每页数量
     * @type {?}
     */
    STChange.prototype.ps;
    /**
     * 数据总量
     * @type {?}
     */
    STChange.prototype.total;
    /**
     * `loaded` 参数
     * @type {?|undefined}
     */
    STChange.prototype.loaded;
    /**
     * `checkbox` 参数
     * @type {?|undefined}
     */
    STChange.prototype.checkbox;
    /**
     * `radio` 参数
     * @type {?|undefined}
     */
    STChange.prototype.radio;
    /**
     * 排序参数
     * @type {?|undefined}
     */
    STChange.prototype.sort;
    /**
     * 过滤参数
     * @type {?|undefined}
     */
    STChange.prototype.filter;
    /**
     * 行点击参数
     * @type {?|undefined}
     */
    STChange.prototype.click;
    /**
     * 行双击参数
     * @type {?|undefined}
     */
    STChange.prototype.dblClick;
    /**
     * `expand` 参数
     * @type {?|undefined}
     */
    STChange.prototype.expand;
}
/**
 * 行单击参数
 * @record
 */
export function STChangeSort() { }
if (false) {
    /** @type {?|undefined} */
    STChangeSort.prototype.value;
    /** @type {?|undefined} */
    STChangeSort.prototype.map;
    /** @type {?|undefined} */
    STChangeSort.prototype.column;
}
/**
 * 行单击参数
 * @record
 */
export function STChangeRowClick() { }
if (false) {
    /** @type {?|undefined} */
    STChangeRowClick.prototype.e;
    /** @type {?|undefined} */
    STChangeRowClick.prototype.item;
    /** @type {?|undefined} */
    STChangeRowClick.prototype.index;
}
/**
 * @record
 */
export function STError() { }
if (false) {
    /** @type {?|undefined} */
    STError.prototype.type;
    /** @type {?|undefined} */
    STError.prototype.error;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st.interfaces.js","sourceRoot":"ng://@lxlib/seed/st/","sources":["st.interfaces.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders, HttpParams } from '@angular/common/http';\nimport { DrawerHelperOptions, ModalHelperOptions, YNMode } from '@lxlib/theme';\nimport { NzDrawerOptions } from 'ng-zorro-antd/drawer';\nimport { ModalOptions } from 'ng-zorro-antd/modal';\nimport { STComponent } from './st.component';\n\nexport interface STWidthMode {\n  /**\n   * 宽度类型\n   * - `default` 默认行为\n   * - `strict` 严格模式，即强制按 `width` 指定的宽度呈现，并根据 `strictBehavior` 类型处理\n   */\n  type?: 'strict' | 'default';\n  /**\n   * 严格模式的处理行为\n   * - `wrap` 强制换行\n   * - `truncate` 截短\n   */\n  strictBehavior?: 'wrap' | 'truncate';\n}\n\nexport interface STResetColumnsOption {\n  pi?: number;\n  ps?: number;\n  columns?: STColumn[];\n  /**\n   * Whether to trigger a data load, default: `true`\n   */\n  emitReload?: boolean;\n}\n\nexport interface STReq {\n  /**\n   * 分页类型，默认：`page`\n   * - `page` 使用 `pi`，`ps` 组合\n   * - `skip` 使用 `skip`，`limit` 组合\n   */\n  type?: 'page' | 'skip';\n  /**\n   * 额外请求参数，默认自动附加 `pi`、`ps` 至URL\n   * - `{ status: 'new' }` => `url?pi=1&ps=10&status=new`\n   */\n  params?: any;\n  /** 请求方法，默认：`GET` */\n  method?: string;\n  /** 请求体 `body` */\n  body?: any;\n  /** 请求体 `Header` */\n  headers?: any;\n  /**\n   * 重命名参数 `pi`、`ps`，默认：`{ pi: 'pi', ps: 'ps' }`\n   * - `{ pi: 'Page' }` => `pi` 会被替换成 Page\n   */\n  reName?: STReqReNameType;\n  /**\n   * 是否将请求所有参数数据都放入 `body` 当中（`url` 地址本身参数除外），仅当 `method: 'POST'` 时有效，默认：`false`\n   */\n  allInBody?: boolean;\n  /**\n   * 是否延迟加载数据，即渲染结束后不会主动发起请求，默认：`false`\n   */\n  lazyLoad?: boolean;\n  /**\n   * 请求前数据处理\n   */\n  process?: (requestOptions: STRequestOptions) => STRequestOptions;\n}\n\nexport interface STRequestOptions {\n  body?: any;\n  headers?:\n    | HttpHeaders\n    | {\n        [header: string]: string | string[];\n      };\n  params?:\n    | HttpParams\n    | {\n        [param: string]: string | string[];\n      };\n  observe?: 'body' | 'events' | 'response';\n  reportProgress?: boolean;\n  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n  withCredentials?: boolean;\n}\n\nexport interface STLoadOptions {\n  /** 是否合并，默认：`false` */\n  merge?: boolean;\n  /** 是否跳转至顶部，若不指定由 `page.toTop` 来决定 */\n  toTop?: boolean;\n}\n\nexport interface STRes {\n  /**\n   * 重命名返回参数 `total`、`list`\n   * - `{ total: 'Total' }` => Total 会被当作 `total`\n   */\n  reName?: STResReNameType;\n  /**\n   * 数据预处理\n   */\n  process?: (data: STData[], rawData?: any) => STData[];\n}\n\nexport interface STPage {\n  /**\n   * 前端分页，当 `data` 为`any[]` 或 `Observable<any[]>` 有效，默认：`true`\n   * - `true` 由 `st` 根据 `data` 长度受控分页，包括：排序、过滤等\n   * - `false` 由用户通过 `total` 和 `data` 参数受控分页，并维护 `(change)` 当分页变更时重新加载数据\n   */\n  front?: boolean;\n  /**\n   * 后端分页是否采用`0`基索引，只在`data`类型为`string`时有效，默认：`false`\n   */\n  zeroIndexed?: boolean;\n  /**\n   * 指定分页显示的位置，默认：`bottom`\n   */\n  position?: 'top' | 'bottom' | 'both';\n  /**\n   * 指定分页分页方向，默认：`right`\n   */\n  placement?: 'left' | 'center' | 'right';\n  /**\n   * 是否显示分页器，默认：`true`\n   */\n  show?: boolean;\n  /**\n   * 是否显示分页器中改变页数，默认：`false`\n   */\n  showSize?: boolean;\n  /**\n   * 分页器中每页显示条目数下拉框值，默认：`[10, 20, 30, 40, 50]`\n   */\n  pageSizes?: number[];\n  /**\n   * 是否显示分页器中快速跳转，默认：`false`\n   */\n  showQuickJumper?: boolean;\n  /**\n   * 是否显示总数据量\n   * - `boolean` 类型显示与否，默认模板：`共 {{total}} 条`\n   * - `string` 自定义模板，模板变量：\n   *  - `{{total}}` 表示数据总量\n   *  - `{{range[0]}}` 表示当前页开始数量值\n   *  - `{{range[1]}}` 表示当前页结束数量值\n   */\n  total?: string | boolean;\n  /**\n   * 切换分页时返回顶部，默认：`true`\n   */\n  toTop?: boolean;\n  /**\n   * 返回顶部偏移值，默认：`100`\n   */\n  toTopOffset?: number;\n}\n\n/**\n * 数据源\n */\nexport interface STData {\n  /**\n   * 选择框或单选框状态值\n   */\n  checked?: boolean;\n  /**\n   * 选择框或单选框 `disabled` 值\n   */\n  disabled?: boolean;\n  /**\n   * 是否展开状态\n   */\n  expand?: boolean;\n  /**\n   * 是否显示展开按钮\n   */\n  showExpand?: boolean;\n\n  [key: string]: any;\n}\n\n/**\n * 列描述\n */\nexport interface STColumn {\n  /**\n   * 用于定义数据源主键，例如：`STStatistical`\n   */\n  key?: string;\n  /**\n   * 列标题\n   */\n  title?: string | STColumnTitle;\n  /**\n   * 列数据在数据项中对应的 key，支持 `a.b.c` 的嵌套写法，例如：\n   * - `id`\n   * - `price.market`\n   * - `[ 'price', 'market' ]`\n   */\n  index?: string | string[] | null;\n  /**\n   * 类型\n   * - `no` 行号，计算规则：`index + noIndex`\n   * - `checkbox` 多选\n   * - `radio` 单选\n   * - `link` 链接，务必指定 `click`\n   * - `badge` [徽标](https://ng.ant.design/components/badge/zh)，务必指定 `badge` 参数配置徽标对应值\n   * - `tag` [标签](https://ng.ant.design/components/tag/zh)，务必指定 `tag` 参数配置标签对应值\n   * - `img` 图片且居中(若 `className` 存在则优先)\n   * - `number` 数字且居右(若 `className` 存在则优先)\n   * - `currency` 货币且居右(若 `className` 存在则优先)\n   * - `date` 日期格式且居中(若 `className` 存在则优先)，使用 `dateFormat` 自定义格式\n   * - `yn` 将`boolean`类型徽章化 [document](https://ng-alain.com/docs/data-render#yn)\n   */\n  type?: 'checkbox' | 'link' | 'badge' | 'tag' | 'radio' | 'img' | 'currency' | 'number' | 'date' | 'yn' | 'no';\n  /**\n   * 链接回调，若返回一个字符串表示导航URL会自动触发 `router.navigateByUrl`\n   */\n  click?: (record: STData, instance?: STComponent) => any;\n  /**\n   * 按钮组\n   */\n  buttons?: STColumnButton[];\n  /**\n   * 自定义渲染ID\n   * @example\n   * <ng-template st-row=\"custom\" let-item let-index=\"index\" let-column=\"column\">\n   *  {{ c.title }}\n   * </ng-template>\n   */\n  render?: string;\n  /**\n   * 标题自定义渲染ID\n   * @example\n   * <ng-template st-row=\"custom\" type=\"title\" let-c>\n   *  {{ item | json }}\n   * </ng-template>\n   */\n  renderTitle?: string;\n  /**\n   * 列宽（数字型表示 `px` 值），例如：`100`、`10%`、`100px`\n   *\n   * **注意：** 若固定列必须是数字\n   */\n  width?: string | number;\n  /**\n   * 排序配置项，远程数据配置**优先**规则：\n   * - `true` 表示允许排序\n   * - `string` 表示远程数据排序相对应 `key` 值\n   */\n  sort?: true | string | STColumnSort;\n  /**\n   * 过滤配置项\n   */\n  filter?: STColumnFilter;\n  /**\n   * 格式化列值\n   */\n  format?: (item: STData, col: STColumn, index: number) => string;\n  /**\n   * 自定义全/反选选择项\n   */\n  selections?: STColumnSelection[];\n  /**\n   * 列 `class` 属性值（注：无须 `.` 点）多个用空格隔开，例如：\n   * - `text-center` 居中\n   * - `text-right` 居右\n   * - `text-success` 成功色\n   * - `text-danger` 异常色\n   */\n  className?: string;\n  /**\n   * 合并列\n   */\n  colSpan?: number;\n  /**\n   * 数字格式，`type=number` 有效\n   */\n  numberDigits?: string;\n  /**\n   * 日期格式，`type=date` 有效，（默认：`yyyy-MM-dd HH:mm`）\n   */\n  dateFormat?: string;\n  /**\n   * 当 `type=yn` 有效\n   */\n  yn?: STColumnYn;\n  /**\n   * 是否允许导出，默认 `true`\n   */\n  exported?: boolean;\n  /**\n   * 权限，等同 [ACLCanType](https://ng-alain.com/acl/getting-started/#ACLCanType) 参数值\n   */\n  acl?: any;\n  /** 当不存在数据时以默认值替代 */\n  default?: string;\n  /**\n   * 固定前后列，当指定时务必指定 `width` 否则视为无效，有若干 **注意：** 项：\n   *\n   * - 若列头与内容不对齐或出现列重复，请指定列的宽度 `width`\n   * - 建议指定 `scroll.x` 为大于表格宽度的固定值或百分比。注意，且非固定列宽度之和不要超过 `scroll.x`\n   */\n  fixed?: 'left' | 'right';\n  /**\n   * 徽标配置项\n   */\n  badge?: STColumnBadge | null;\n  /**\n   * 标签配置项\n   */\n  tag?: STColumnTag | null;\n  /**\n   * 行号索引，默认：`1`\n   * - 计算规则为：`index + noIndex`\n   * - 支持自定义方法\n   */\n  noIndex?: number | ((item: STData, col: STColumn, idx: number) => number);\n  /**\n   * 条件表达式\n   * - 仅赋值 `columns` 时执行一次\n   * - 可调用 `resetColumns()` 再一次触发\n   */\n  iif?: (item: STColumn) => boolean;\n\n  /**\n   * 统计\n   */\n  statistical?: STStatisticalType | STStatistical;\n\n  /** @ignore internal property */\n  _sort?: STSortMap;\n\n  [key: string]: any;\n}\n\nexport interface STColumnTitle {\n  [key: string]: any;\n\n  /**\n   * Text of header, can be choose one of `text` or `i18n`\n   */\n  text?: string;\n\n  /**\n   * I18n key of header, can be choose one of `text` or `i18n`\n   */\n  i18n?: string;\n\n  /**\n   * Optional information of header\n   */\n  optional?: string;\n\n  /**\n   * Optional help of header\n   */\n  optionalHelp?: string;\n}\n\nexport type STStatisticalType = 'count' | 'distinctCount' | 'sum' | 'average' | 'max' | 'min';\n\nexport type STStatisticalFn = (values: number[], col: STColumn, list: STData[], rawData?: any) => STStatisticalResult;\n\nexport interface STStatistical {\n  type: STStatisticalType | STStatisticalFn;\n  /**\n   * 保留小数位数，默认：`2`\n   */\n  digits?: number;\n  /**\n   * 是否需要货币格式化，默认以下情况为 `true`\n   * - `type` 为 `STStatisticalFn`、 `sum`、`average`、`max`、`min`\n   */\n  currency?: boolean;\n}\n\nexport interface STStatisticalResults {\n  [key: string]: STStatisticalResult;\n  [index: number]: STStatisticalResult;\n}\n\nexport interface STStatisticalResult {\n  value: number;\n  text?: string;\n}\n\nexport interface STColumnSort {\n  /**\n   * 排序的默认受控属性\n   */\n  default?: 'ascend' | 'descend' | null;\n  /**\n   * 本地数据的排序函数，使用一个函数(参考 [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) 的 compareFunction)\n   * - `null` 忽略本地排序，但保持排序功能\n   */\n  compare?: ((a: STData, b: STData) => number) | null;\n  /**\n   * 远程数据的排序时后端相对应的KEY，默认使用 `index` 属性\n   * - 若 `multiSort: false` 时：`key: 'name' => ?name=1&pi=1`\n   * - 若 `multiSort: true` 允许多个排序 key 存在，或使用 `STMultiSort` 指定多列排序key合并规则\n   */\n  key?: string | null;\n  /**\n   * 远程数据的排序时后端相对应的VALUE\n   * - `{ ascend: '0', descend: '1' }` 结果 `?name=1&pi=1`\n   * - `{ ascend: 'asc', descend: 'desc' }` 结果 `?name=desc&pi=1`\n   */\n  reName?: { ascend?: string; descend?: string };\n}\n\nexport interface STSortMap extends STColumnSort {\n  [key: string]: any;\n\n  /** 是否启用排序 */\n  enabled?: boolean;\n}\n\nexport interface STColumnFilter {\n  /**\n   * 搜索方式\n   * - `defualt` 默认形式\n   * - `keyword` 文本框形式\n   */\n  type?: 'default' | 'keyword';\n  /**\n   * 表头的筛选菜单项，至少一项才会生效\n   * - 当 `type='keyword'` 时可为空\n   */\n  menus?: STColumnFilterMenu[];\n  /**\n   * 本地数据的筛选函数\n   */\n  fn?: ((filter: STColumnFilterMenu, record: STData) => boolean) | null;\n  /**\n   * 标识数据是否已过滤，筛选图标会高亮\n   */\n  default?: boolean;\n  /**\n   * 自定义 filter 图标\n   * - 当 `type='default'` 默认 `filter`\n   * - 当 `type='keyword'` 默认 `search`\n   */\n  icon?: string | STIcon;\n  /**\n   * 确认按钮文本，默认 `确认`\n   */\n  confirmText?: string;\n  /**\n   * 清除按钮文本，默认 `重置`\n   */\n  clearText?: string;\n  /**\n   * 是否多选，默认 `true`\n   */\n  multiple?: boolean;\n  /**\n   * 远程数据的过滤时后端相对应的KEY，默认使用 `index` 属性\n   * `key: 'name'` 结果 `?name=1&pi=1`\n   */\n  key?: string | null;\n  /**\n   * 远程数据的过滤时后端相对应的VALUE\n   * - 默认当 `multiple: true` 时以英文逗号拼接的字符串\n   * @return 返回为 Object 对象\n   */\n  reName?: (list: STColumnFilterMenu[], col: STColumn) => {};\n}\n\nexport interface STColumnFilterMenu {\n  /**\n   * 文本\n   * - 当 `type: 'keyword'` 时表示 `placeholder`\n   */\n  text?: string;\n  /**\n   * 值\n   */\n  value?: any;\n  /**\n   * 是否选中\