@zhin.js/database 1.0.4 → 1.0.6

package/src/types.ts

@@ -6,8 +6,22 @@ export type QueryType =
   | 'drop_index' 
   | 'select' 
   | 'insert' 
+  | 'insert_many'
   | 'update' 
-  | 'delete';
+  | 'delete'
+  | 'aggregate';
+
+// ============================================================================
+// Aggregation Types
+// ============================================================================
+
+export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+
+export interface AggregateField<T extends object> {
+  fn: AggregateFunction;
+  field: keyof T | '*';
+  alias?: string;
+}
 
 // ============================================================================
 // Column Type Definitions
@@ -35,6 +49,70 @@ export type Definition<T extends object=object> = {
   [P in keyof T]: Column<T[P]>;
 }
 
+// ============================================================================
+// Model Options
+// ============================================================================
+
+export interface ModelOptions {
+  /** 启用软删除（需要表中有 deletedAt 字段） */
+  softDelete?: boolean;
+  /** 软删除字段名，默认 'deletedAt' */
+  deletedAtField?: string;
+  /** 启用自动时间戳（createdAt, updatedAt） */
+  timestamps?: boolean;
+  /** createdAt 字段名，默认 'createdAt' */
+  createdAtField?: string;
+  /** updatedAt 字段名，默认 'updatedAt' */
+  updatedAtField?: string;
+}
+
+// ============================================================================
+// Lifecycle Hooks Types
+// ============================================================================
+
+/**
+ * 生命周期钩子上下文
+ * 包含当前操作的相关信息
+ */
+export interface HookContext<T extends object = object> {
+  /** 模型名称 */
+  modelName: string;
+  /** 当前操作的数据（create/update 时） */
+  data?: Partial<T>;
+  /** 查询条件（find/update/delete 时） */
+  where?: Condition<T>;
+  /** 操作结果（after 钩子时） */
+  result?: T | T[] | number;
+}
+
+/**
+ * 钩子函数类型
+ * 返回 false 可以取消操作（仅 before 钩子）
+ */
+export type HookFn<T extends object = object> = (
+  context: HookContext<T>
+) => void | boolean | Promise<void | boolean>;
+
+/**
+ * 生命周期钩子名称
+ */
+export type HookName = 
+  | 'beforeCreate'
+  | 'afterCreate'
+  | 'beforeUpdate'
+  | 'afterUpdate'
+  | 'beforeDelete'
+  | 'afterDelete'
+  | 'beforeFind'
+  | 'afterFind';
+
+/**
+ * 钩子配置
+ */
+export type HooksConfig<T extends object = object> = {
+  [K in HookName]?: HookFn<T> | HookFn<T>[];
+};
+
 // ============================================================================
 // Column Alteration Types
 // ============================================================================
@@ -64,6 +142,21 @@ export type AlterDefinition<T extends object> = {
   [P in keyof T]?: AddDefinition<T[P]> | ModifyDefinition<T[P]> | DropDefinition
 };
 
+// ============================================================================
+// Subquery Types
+// ============================================================================
+
+/**
+ * 子查询标识接口
+ * @template T 子查询返回的字段类型
+ */
+export interface Subquery<T = any> {
+  readonly __isSubquery: true;
+  /** 子查询返回值类型标记（仅用于类型推断，运行时不存在） */
+  readonly __returnType?: T;
+  toSQL(): { sql: string; params: any[] };
+}
+
 // ============================================================================
 // Condition Types
 // ============================================================================
@@ -75,8 +168,10 @@ export interface ComparisonOperators<T> {
   $gte?: T;
   $lt?: T;
   $lte?: T;
-  $in?: T[];
-  $nin?: T[];
+  /** 值在数组中或子查询结果中 */
+  $in?: T[] | Subquery<T>;
+  /** 值不在数组中或子查询结果中 */
+  $nin?: T[] | Subquery<T>;
   $like?: string;
   $nlike?: string;
 }
@@ -102,70 +197,116 @@ export interface Ordering<T extends object> {
   direction: SortDirection;
 }
 
+// ============================================================================
+// JOIN Types
+// ============================================================================
+
+export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+
+/**
+ * JOIN 子句定义
+ * @template S Schema 类型
+ * @template T 主表
+ * @template J 关联表
+ */
+export interface JoinClause<
+  S extends Record<string, object>,
+  T extends keyof S,
+  J extends keyof S
+> {
+  /** JOIN 类型 */
+  type: JoinType;
+  /** 关联表名 */
+  table: J;
+  /** 主表字段 */
+  leftField: keyof S[T];
+  /** 关联表字段 */
+  rightField: keyof S[J];
+  /** 表别名（可选） */
+  alias?: string;
+}
+
 // ============================================================================
 // Query Parameter Types (Discriminated Union)
 // ============================================================================
 
-export interface BaseQueryParams {
-  tableName: string;
+export interface BaseQueryParams<S extends Record<string, object> = Record<string, object>, T extends keyof S = keyof S>  {
+  tableName: T;
 }
 
-export interface CreateQueryParams<T extends object = any> extends BaseQueryParams {
+export interface CreateQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'create';
-  definition: Definition<T>;
+  definition: Definition<S[T]>;
 }
 
-export interface AlterQueryParams<T extends object = any> extends BaseQueryParams {
+export interface AlterQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'alter';
-  alterations: AlterDefinition<T>;
+  alterations: AlterDefinition<S[T]>;
 }
 
-export interface DropTableQueryParams<T extends object = any> extends BaseQueryParams {
+export interface DropTableQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'drop_table';
-  conditions?: Condition<T>;
+  conditions?: Condition<S[T]>;
 }
 
-export interface DropIndexQueryParams extends BaseQueryParams {
+export interface DropIndexQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'drop_index';
   indexName: string;
   conditions?: Condition<any>;
 }
 
-export interface SelectQueryParams<T extends object = any> extends BaseQueryParams {
+export interface SelectQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'select';
-  fields?: (keyof T)[];
-  conditions?: Condition<T>;
-  groupings?: (keyof T)[];
-  orderings?: Ordering<T>[];
+  fields?: (keyof S[T])[];
+  conditions?: Condition<S[T]>;
+  groupings?: (keyof S[T])[];
+  orderings?: Ordering<S[T]>[];
   limitCount?: number;
   offsetCount?: number;
+  /** JOIN 子句列表 */
+  joins?: JoinClause<S, T, keyof S>[];
 }
 
-export interface InsertQueryParams<T extends object = any> extends BaseQueryParams {
+export interface InsertQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'insert';
-  data: T;
+  data: S[T];
+}
+
+export interface InsertManyQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
+  type: 'insert_many';
+  data: S[T][];
 }
 
-export interface UpdateQueryParams<T extends object = any> extends BaseQueryParams {
+export interface UpdateQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'update';
-  update: Partial<T>;
-  conditions?: Condition<T>;
+  update: Partial<S[T]>;
+  conditions?: Condition<S[T]>;
 }
 
-export interface DeleteQueryParams<T extends object = any> extends BaseQueryParams {
+export interface DeleteQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
   type: 'delete';
-  conditions?: Condition<T>;
+  conditions?: Condition<S[T]>;
 }
 
-export type QueryParams<T extends object = any> = 
-  | CreateQueryParams<T>
-  | AlterQueryParams<T>
-  | DropTableQueryParams<T>
-  | DropIndexQueryParams
-  | SelectQueryParams<T>
-  | InsertQueryParams<T>
-  | UpdateQueryParams<T>
-  | DeleteQueryParams<T>;
+export interface AggregateQueryParams<S extends Record<string, object>, T extends keyof S> extends BaseQueryParams<S,T> {
+  type: 'aggregate';
+  aggregates: AggregateField<S[T]>[];
+  conditions?: Condition<S[T]>;
+  groupings?: (keyof S[T])[];
+  havingConditions?: Condition<S[T]>;
+}
+
+export type QueryParams<S extends Record<string, object>,T extends keyof S> = 
+  | CreateQueryParams<S,T>
+  | AlterQueryParams<S,T>
+  | DropTableQueryParams<S,T>
+  | DropIndexQueryParams<S,T>
+  | SelectQueryParams<S,T>
+  | InsertQueryParams<S,T>
+  | InsertManyQueryParams<S,T>
+  | UpdateQueryParams<S,T>
+  | DeleteQueryParams<S,T>
+  | AggregateQueryParams<S,T>;
 
 // ============================================================================
 // Query Result Types
@@ -271,8 +412,6 @@ export interface BaseDriverConfig {
 }
 
 
-export interface MemoryConfig{
-}
 
 
 // ============================================================================
@@ -286,6 +425,91 @@ export interface DriverConnection {
   healthCheck(): Promise<boolean>;
 }
 
+// ============================================================================
+// Transaction Types
+// ============================================================================
+
+export type IsolationLevel = 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE';
+
+export interface TransactionOptions {
+  isolationLevel?: IsolationLevel;
+  timeout?: number;
+}
+
+export interface Transaction {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+  query<T = any>(sql: string, params?: any[]): Promise<T>;
+}
+
+/**
+ * 增强的事务接口，支持链式调用
+ */
+export interface TransactionContext<S extends Record<string, object> = Record<string, object>> extends Transaction {
+  /**
+   * 插入单条数据
+   */
+  insert<T extends keyof S>(tableName: T, data: S[T]): Promise<S[T]>;
+  
+  /**
+   * 批量插入数据
+   */
+  insertMany<T extends keyof S>(tableName: T, data: S[T][]): Promise<{ affectedRows: number }>;
+  
+  /**
+   * 查询数据
+   */
+  select<T extends keyof S>(tableName: T, fields?: (keyof S[T])[]): TransactionSelection<S, T>;
+  
+  /**
+   * 更新数据
+   */
+  update<T extends keyof S>(tableName: T, data: Partial<S[T]>): TransactionUpdation<S, T>;
+  
+  /**
+   * 删除数据
+   */
+  delete<T extends keyof S>(tableName: T): TransactionDeletion<S, T>;
+}
+
+/**
+ * 事务查询选择器
+ */
+export interface TransactionSelection<S extends Record<string, object>, T extends keyof S> {
+  where(condition: Condition<S[T]>): this;
+  orderBy(field: keyof S[T], direction?: 'ASC' | 'DESC'): this;
+  limit(count: number): this;
+  offset(count: number): this;
+  then<R>(onfulfilled?: (value: S[T][]) => R | PromiseLike<R>): Promise<R>;
+}
+
+/**
+ * 事务更新器
+ */
+export interface TransactionUpdation<S extends Record<string, object>, T extends keyof S> {
+  where(condition: Condition<S[T]>): this;
+  then<R>(onfulfilled?: (value: number) => R | PromiseLike<R>): Promise<R>;
+}
+
+/**
+ * 事务删除器
+ */
+export interface TransactionDeletion<S extends Record<string, object>, T extends keyof S> {
+  where(condition: Condition<S[T]>): this;
+  then<R>(onfulfilled?: (value: number) => R | PromiseLike<R>): Promise<R>;
+}
+
+// ============================================================================
+// Connection Pool Types
+// ============================================================================
+
+export interface PoolConfig {
+  min?: number;
+  max?: number;
+  acquireTimeoutMillis?: number;
+  idleTimeoutMillis?: number;
+}
+
 export interface DriverQuery {
   query<T = any>(sql: string, params?: any[]): Promise<T>;
 }
@@ -296,7 +520,7 @@ export interface DriverSchema {
 }
 
 export interface DriverQueryBuilder<R> {
-  buildQuery<T extends object = any>(params: QueryParams<T>): BuildQueryResult<R>;
+  buildQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): BuildQueryResult<R>;
 }
 
 export interface DriverLifecycle {
@@ -370,34 +594,325 @@ export type DeepRequired<T> = {
 // Type Guards
 // ============================================================================
 
-export function isCreateQuery<T extends object>(params: QueryParams<T>): params is CreateQueryParams<T> {
+export function isCreateQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is CreateQueryParams<S, T> {
   return params.type === 'create';
 }
 
-export function isAlterQuery<T extends object>(params: QueryParams<T>): params is AlterQueryParams<T> {
+export function isAlterQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is AlterQueryParams<S, T> {
   return params.type === 'alter';
 }
 
-export function isSelectQuery<T extends object>(params: QueryParams<T>): params is SelectQueryParams<T> {
+export function isSelectQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is SelectQueryParams<S, T> {
   return params.type === 'select';
 }
 
-export function isInsertQuery<T extends object>(params: QueryParams<T>): params is InsertQueryParams<T> {
+export function isInsertQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is InsertQueryParams<S, T> {
   return params.type === 'insert';
 }
 
-export function isUpdateQuery<T extends object>(params: QueryParams<T>): params is UpdateQueryParams<T> {
+export function isUpdateQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is UpdateQueryParams<S, T> {
   return params.type === 'update';
 }
 
-export function isDeleteQuery<T extends object>(params: QueryParams<T>): params is DeleteQueryParams<T> {
+export function isDeleteQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is DeleteQueryParams<S, T> {
   return params.type === 'delete';
 }
 
-export function isDropTableQuery<T extends object>(params: QueryParams<T>): params is DropTableQueryParams<T> {
+export function isDropTableQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is DropTableQueryParams<S, T> {
   return params.type === 'drop_table';
 }
 
-export function isDropIndexQuery(params: QueryParams): params is DropIndexQueryParams {
+export function isDropIndexQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is DropIndexQueryParams<S,T> {
   return params.type === 'drop_index';
 }
+
+export function isInsertManyQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is InsertManyQueryParams<S, T> {
+  return params.type === 'insert_many';
+}
+
+export function isAggregateQuery<S extends Record<string, object>, T extends keyof S>(params: QueryParams<S, T>): params is AggregateQueryParams<S, T> {
+  return params.type === 'aggregate';
+}
+
+// ============================================================================
+// Relations Types
+// ============================================================================
+
+/**
+ * 关联关系类型
+ */
+export type RelationType = 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+
+/**
+ * Schema 中的关系声明
+ * 
+ * @example
+ * ```ts
+ * interface MySchema {
+ *   users: {
+ *     id: number;
+ *     name: string;
+ *     $hasMany: { orders: 'userId' };
+ *     $hasOne: { profile: 'userId' };
+ *   };
+ *   orders: {
+ *     id: number;
+ *     userId: number;
+ *     $belongsTo: { users: 'userId' };
+ *   };
+ * }
+ * ```
+ */
+export interface SchemaRelations<S extends Record<string, object>> {
+  /** 一对多关系: { 目标表名: '外键字段' } */
+  $hasMany?: { [K in keyof S]?: string };
+  /** 一对一关系: { 目标表名: '外键字段' } */
+  $hasOne?: { [K in keyof S]?: string };
+  /** 多对一关系: { 目标表名: '本表外键字段' } */
+  $belongsTo?: { [K in keyof S]?: string };
+}
+
+/**
+ * 从 Schema 表定义中提取纯数据字段（排除关系声明）
+ */
+export type SchemaFields<T> = Omit<T, '$hasMany' | '$hasOne' | '$belongsTo'>;
+
+/**
+ * 关联关系定义
+ */
+export interface RelationDefinition<
+  S extends Record<string, object>,
+  From extends keyof S,
+  To extends keyof S
+> {
+  /** 关联类型 */
+  type: RelationType;
+  /** 目标表名 */
+  target: To;
+  /** 本表外键字段 */
+  foreignKey: keyof S[From] | keyof S[To];
+  /** 目标表主键字段（默认 'id'） */
+  targetKey?: keyof S[To];
+  /** 本表主键字段（默认 'id'） */
+  localKey?: keyof S[From];
+  /** 中间表配置（仅 belongsToMany） */
+  pivot?: PivotConfig;
+}
+
+/**
+ * 中间表（Pivot Table）配置
+ * 用于多对多关系
+ */
+export interface PivotConfig {
+  /** 中间表名 */
+  table: string;
+  /** 中间表中指向源表的外键 */
+  foreignPivotKey: string;
+  /** 中间表中指向目标表的外键 */
+  relatedPivotKey: string;
+  /** 中间表额外字段（可选） */
+  pivotFields?: string[];
+  /** 是否包含时间戳 */
+  timestamps?: boolean;
+}
+
+/**
+ * 带关联数据的结果类型
+ */
+export type WithRelation<
+  T extends object,
+  RelName extends string,
+  RelType extends 'hasOne' | 'belongsTo' | 'hasMany' | 'belongsToMany',
+  RelData extends object
+> = T & {
+  [K in RelName]: RelType extends ('hasMany' | 'belongsToMany') ? RelData[] : RelData | null;
+};
+
+/**
+ * 带中间表数据的关联结果
+ */
+export type WithPivot<T extends object, PivotData extends object = Record<string, any>> = T & {
+  pivot: PivotData;
+};
+
+/**
+ * 关联查询选项
+ */
+export interface RelationQueryOptions<S extends Record<string, object>, T extends keyof S> {
+  /** 要加载的关联名称 */
+  relations?: string[];
+  /** 关联数据的筛选条件 */
+  where?: Condition<S[T]>;
+}
+
+/**
+ * 关系配置中的外键字段类型
+ * 表名是强类型的，字段名是 string（运行时验证）
+ */
+export type RelationForeignKey = string;
+
+/**
+ * hasMany 关系配置：{ 目标表名: 外键字段名 }
+ */
+export type HasManyConfig<S extends Record<string, object>> = {
+  [K in Extract<keyof S, string>]?: RelationForeignKey;
+};
+
+/**
+ * hasOne 关系配置：{ 目标表名: 外键字段名 }
+ */
+export type HasOneConfig<S extends Record<string, object>> = {
+  [K in Extract<keyof S, string>]?: RelationForeignKey;
+};
+
+/**
+ * belongsTo 关系配置：{ 目标表名: 本表外键字段名 }
+ */
+export type BelongsToConfig<S extends Record<string, object>> = {
+  [K in Extract<keyof S, string>]?: RelationForeignKey;
+};
+
+/**
+ * belongsToMany 关系配置
+ * { 目标表名: { pivot: 中间表名, foreignKey: 源外键, relatedKey: 目标外键, pivotFields?: 额外字段 } }
+ */
+export interface BelongsToManyRelationConfig {
+  /** 中间表名 */
+  pivot: string;
+  /** 中间表中指向源表的外键 */
+  foreignKey: string;
+  /** 中间表中指向目标表的外键 */
+  relatedKey: string;
+  /** 要获取的中间表额外字段 */
+  pivotFields?: string[];
+}
+
+export type BelongsToManyConfig<S extends Record<string, object>> = {
+  [K in Extract<keyof S, string>]?: BelongsToManyRelationConfig;
+};
+
+/**
+ * 单个表的关系配置
+ */
+export interface TableRelationsConfig<S extends Record<string, object>> {
+  hasMany?: HasManyConfig<S>;
+  hasOne?: HasOneConfig<S>;
+  belongsTo?: BelongsToConfig<S>;
+  belongsToMany?: BelongsToManyConfig<S>;
+}
+
+/**
+ * 关系配置对象（用于 Database 构造）
+ * 
+ * 表名是强类型的（必须是 Schema 中定义的表），
+ * 字段名是字符串（在运行时通过模型方法验证）
+ * 
+ * @example
+ * ```ts
+ * interface Schema {
+ *   users: { id: number; name: string };
+ *   orders: { id: number; userId: number };
+ * }
+ * 
+ * db.defineRelations({
+ *   users: {
+ *     hasMany: { orders: 'userId' }  // ✅ 'orders' 是有效表名
+ *   },
+ *   orders: {
+ *     belongsTo: { users: 'userId' } // ✅ 'users' 是有效表名
+ *   },
+ *   // wrongTable: {}  // ❌ 类型错误：'wrongTable' 不在 Schema 中
+ * });
+ * ```
+ */
+export type RelationsConfig<S extends Record<string, object>> = {
+  [T in Extract<keyof S, string>]?: TableRelationsConfig<S>;
+};
+
+// ============================================================================
+// Migration Types
+// ============================================================================
+
+/**
+ * 迁移上下文 - 提供迁移操作所需的数据库方法
+ */
+export interface MigrationContext {
+  /** 创建表 */
+  createTable(tableName: string, columns: Record<string, Column>): Promise<void>;
+  /** 删除表 */
+  dropTable(tableName: string): Promise<void>;
+  /** 添加列 */
+  addColumn(tableName: string, columnName: string, column: Column): Promise<void>;
+  /** 删除列 */
+  dropColumn(tableName: string, columnName: string): Promise<void>;
+  /** 修改列 */
+  modifyColumn(tableName: string, columnName: string, column: Column): Promise<void>;
+  /** 重命名列 */
+  renameColumn(tableName: string, oldName: string, newName: string): Promise<void>;
+  /** 添加索引 */
+  addIndex(tableName: string, indexName: string, columns: string[], unique?: boolean): Promise<void>;
+  /** 删除索引 */
+  dropIndex(tableName: string, indexName: string): Promise<void>;
+  /** 执行原生 SQL */
+  query<T = any>(sql: string, params?: any[]): Promise<T>;
+}
+
+/**
+ * 迁移定义
+ */
+/**
+ * 迁移操作记录（用于自动生成 down）
+ */
+export type MigrationOperation = 
+  | { type: 'createTable'; tableName: string; columns: Record<string, Column> }
+  | { type: 'dropTable'; tableName: string }
+  | { type: 'addColumn'; tableName: string; columnName: string; column: Column }
+  | { type: 'dropColumn'; tableName: string; columnName: string }
+  | { type: 'addIndex'; tableName: string; indexName: string; columns: string[]; unique?: boolean }
+  | { type: 'dropIndex'; tableName: string; indexName: string }
+  | { type: 'renameColumn'; tableName: string; oldName: string; newName: string }
+  | { type: 'query'; sql: string; params?: any[] };
+
+export interface Migration {
+  /** 迁移名称（唯一标识） */
+  name: string;
+  /** 迁移版本（时间戳或序号） */
+  version?: string | number;
+  /** 升级操作 */
+  up(context: MigrationContext): Promise<void>;
+  /** 
+   * 降级操作（可选）
+   * 如果不提供，将自动根据 up 操作生成反向操作
+   */
+  down?(context: MigrationContext): Promise<void>;
+}
+
+/**
+ * 迁移记录（存储在数据库中）
+ */
+export interface MigrationRecord {
+  id: number;
+  name: string;
+  batch: number;
+  executedAt: Date;
+}
+
+/**
+ * 迁移状态
+ */
+export interface MigrationStatus {
+  name: string;
+  status: 'pending' | 'executed';
+  batch?: number;
+  executedAt?: Date;
+}
+
+/**
+ * 迁移运行器配置
+ */
+export interface MigrationRunnerConfig {
+  /** 迁移记录表名 */
+  tableName?: string;
+  /** 迁移文件目录 */
+  migrationsPath?: string;
+}