@currentjs/gen 0.5.0 → 0.5.2

package/dist/generators/templates/data/frontendScriptTemplate

@@ -374,7 +374,10 @@ window.AppConfig = {
    */
   function navigateToPage(url, targetElement = null) {
     const target = targetElement || document.querySelector('#main');
-    if (!target) return;
+    if (!target) {
+      window.location.href = url;
+      return;
+    }
     
     showLoading('#main');
     
@@ -388,18 +391,22 @@ window.AppConfig = {
         if (!response.ok) {
           throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
+        const targetLayout = response.headers.get('X-Layout') || '';
+        const currentLayout = (document.querySelector('meta[name="app-layout"]') || {}).content || '';
+        if (targetLayout !== currentLayout) {
+          window.location.href = url;
+          return null;
+        }
         return response.text();
       })
       .then(html => {
+        if (html === null) return;
         target.innerHTML = html;
-        // Update browser history
         window.history.pushState({}, '', url);
-        // No need to re-initialize - delegation handles new content automatically
       })
       .catch(error => {
         console.error('Navigation failed:', error);
         showToast('Failed to load page', 'error');
-        // Fallback to normal navigation
         window.location.href = url;
       })
       .finally(() => {

package/dist/generators/templates/data/mainViewTemplate

@@ -5,6 +5,7 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Your App</title>
+  <meta name="app-layout" content="main_view">
   <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
   <script src="/app.js"></script>
 </head>

package/dist/generators/templates/storeTemplates.d.ts

@@ -2,4 +2,4 @@ export declare const storeTemplates: {
     rowInterface: string;
     storeClass: string;
 };
-export declare const storeFileTemplate = "import { Injectable } from '../../../../system';\nimport { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}\n\n{{ROW_INTERFACE}}\n\n{{STORE_CLASS}}\n";
+export declare const storeFileTemplate = "import { Injectable } from '../../../../system';\nimport { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}\n\n{{ROW_INTERFACE}}\n\n{{STORE_CLASS}}\n";

package/dist/generators/templates/storeTemplates.js

@@ -29,30 +29,7 @@ export class {{ENTITY_NAME}}Store {
     );
   }
 
-  async getAll(page: number = 1, limit: number = 20): Promise<{{ENTITY_NAME}}[]> {
-    const offset = (page - 1) * limit;
-    const result = await this.db.query(
-      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL LIMIT :limit OFFSET :offset\`,
-      { limit: String(limit), offset: String(offset) }
-    );
-
-    if (result.success && result.data) {
-      return result.data.map((row: {{ENTITY_NAME}}Row) => this.rowToModel(row));
-    }
-    return [];
-  }
-
-  async count(): Promise<number> {
-    const result = await this.db.query(
-      \`SELECT COUNT(*) as count FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL\`,
-      {}
-    );
-
-    if (result.success && result.data && result.data.length > 0) {
-      return parseInt(result.data[0].count, 10);
-    }
-    return 0;
-  }
+{{LIST_METHODS}}
 
   async getById(id: number): Promise<{{ENTITY_NAME}} | null> {
     const result = await this.db.query(
@@ -134,8 +111,8 @@ export class {{ENTITY_NAME}}Store {
 {{GET_RESOURCE_OWNER_METHOD}}}`
 };
 exports.storeFileTemplate = `import { Injectable } from '../../../../system';
-import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';
-import type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}
+import { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';
+import type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}
 
 {{ROW_INTERFACE}}
 

package/dist/generators/useCaseGenerator.js

@@ -71,8 +71,8 @@ class UseCaseGenerator {
                 let params = '';
                 if (defaultAction === 'list') {
                     params = ((_a = useCaseConfig.input) === null || _a === void 0 ? void 0 : _a.pagination)
-                        ? 'input.page || 1, input.limit || 20'
-                        : '';
+                        ? 'input.page || 1, input.limit || 20, ownerId'
+                        : 'ownerId';
                 }
                 else if (defaultAction === 'get') {
                     params = 'input.id';
@@ -99,7 +99,10 @@ class UseCaseGenerator {
             }
         }).join('\n');
         const returnStatement = '\n    return result;';
-        return `  async ${methodName}(input: ${inputType}): Promise<${returnType}> {
+        const methodParams = actionName === 'list'
+            ? `input: ${inputType}, ownerId?: number`
+            : `input: ${inputType}`;
+        return `  async ${methodName}(${methodParams}): Promise<${returnType}> {
 ${handlerCalls}${returnStatement}
   }`;
     }

package/dist/types/configTypes.d.ts

@@ -22,6 +22,11 @@ export interface AggregateFieldConfig {
     unique?: boolean;
     auto?: boolean;
     values?: string[];
+    constraints?: {
+        min?: number;
+        max?: number;
+        pattern?: string;
+    };
 }
 export interface AggregateConfig {
     root?: boolean;
@@ -121,6 +126,7 @@ export interface WebPageConfig {
     method?: 'GET' | 'POST';
     useCase?: string;
     view?: string;
+    layout?: string;
     auth?: AuthConfig;
     onSuccess?: {
         redirect?: string;

package/dist/utils/migrationUtils.d.ts

@@ -1,16 +1,6 @@
-export interface FieldConfig {
-    name: string;
-    type: string;
-    required?: boolean;
-    unique?: boolean;
-    auto?: boolean;
-}
-export interface ModelConfig {
-    name: string;
-    fields: FieldConfig[];
-}
+import { AggregateConfig, AggregateFieldConfig } from '../types/configTypes';
 export interface SchemaState {
-    models: ModelConfig[];
+    aggregates: Record<string, AggregateConfig>;
     version: string;
     timestamp: string;
 }
@@ -31,19 +21,19 @@ export interface ForeignKeyInfo {
     REFERENCED_TABLE_NAME: string;
     REFERENCED_COLUMN_NAME: string;
 }
-export declare function mapYamlTypeToSql(yamlType: string, availableModels: Set<string>): string;
-export declare function getTableName(modelName: string): string;
+export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>): string;
+export declare function getTableName(aggregateName: string): string;
 export declare function getForeignKeyFieldName(fieldName: string): string;
-export declare function isRelationshipField(fieldType: string, availableModels: Set<string>): boolean;
-export declare function generateCreateTableSQL(model: ModelConfig, availableModels: Set<string>): string;
+export declare function isRelationshipField(fieldType: string, availableAggregates: Set<string>): boolean;
+export declare function generateCreateTableSQL(name: string, aggregate: AggregateConfig, availableAggregates: Set<string>): string;
 export declare function generateDropTableSQL(tableName: string): string;
-export declare function generateAddColumnSQL(tableName: string, field: FieldConfig, availableModels: Set<string>): string;
+export declare function generateAddColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>): string;
 export declare function generateDropColumnSQL(tableName: string, columnName: string): string;
-export declare function generateModifyColumnSQL(tableName: string, field: FieldConfig, availableModels: Set<string>): string;
+export declare function generateModifyColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>): string;
 export declare function loadSchemaState(stateFilePath: string): SchemaState | null;
 export declare function saveSchemaState(stateFilePath: string, state: SchemaState): void;
 export declare function loadMigrationLog(logFilePath: string): MigrationLog;
 export declare function saveMigrationLog(logFilePath: string, log: MigrationLog): void;
-export declare function compareSchemas(oldState: SchemaState | null, newModels: ModelConfig[]): string[];
+export declare function compareSchemas(oldState: SchemaState | null, newAggregates: Record<string, AggregateConfig>): string[];
 export declare function generateTimestamp(): string;
 export declare function getMigrationFileName(timestamp: string): string;

package/dist/utils/migrationUtils.js

@@ -61,39 +61,33 @@ const TYPE_MAPPING = {
     array: 'JSON',
     object: 'JSON'
 };
-function mapYamlTypeToSql(yamlType, availableModels) {
-    // Check if this is a relationship (foreign key)
-    if (availableModels.has(yamlType)) {
-        return 'INT'; // Foreign keys are INT
+function mapYamlTypeToSql(yamlType, availableAggregates) {
+    if (availableAggregates.has(yamlType)) {
+        return 'INT';
     }
     return TYPE_MAPPING[yamlType] || 'VARCHAR(255)';
 }
-function getTableName(modelName) {
-    return modelName.toLowerCase() + 's';
+function getTableName(aggregateName) {
+    return aggregateName.toLowerCase() + 's';
 }
 function getForeignKeyFieldName(fieldName) {
     return fieldName + 'Id';
 }
-function isRelationshipField(fieldType, availableModels) {
-    return availableModels.has(fieldType);
+function isRelationshipField(fieldType, availableAggregates) {
+    return availableAggregates.has(fieldType);
 }
-function generateCreateTableSQL(model, availableModels) {
-    const tableName = getTableName(model.name);
+function generateCreateTableSQL(name, aggregate, availableAggregates) {
+    const tableName = getTableName(name);
     const columns = [];
     const indexes = [];
     const foreignKeys = [];
-    // Add id column
     columns.push('  id INT AUTO_INCREMENT PRIMARY KEY');
-    // Add model fields
-    model.fields.forEach(field => {
-        if (isRelationshipField(field.type, availableModels)) {
-            // Foreign key field
-            const foreignKeyName = getForeignKeyFieldName(field.name);
+    for (const [fieldName, field] of Object.entries(aggregate.fields)) {
+        if (isRelationshipField(field.type, availableAggregates)) {
+            const foreignKeyName = getForeignKeyFieldName(fieldName);
             const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
             columns.push(`  ${foreignKeyName} INT ${nullable}`);
-            // Add index for foreign key
             indexes.push(`  INDEX idx_${tableName}_${foreignKeyName} (${foreignKeyName})`);
-            // Add foreign key constraint
             const refTableName = getTableName(field.type);
             foreignKeys.push(`  CONSTRAINT fk_${tableName}_${foreignKeyName} \n` +
                 `    FOREIGN KEY (${foreignKeyName}) \n` +
@@ -102,58 +96,50 @@ function generateCreateTableSQL(model, availableModels) {
                 `    ON UPDATE CASCADE`);
         }
         else {
-            // Regular field
-            const sqlType = mapYamlTypeToSql(field.type, availableModels);
+            const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
             const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-            columns.push(`  ${field.name} ${sqlType} ${nullable}`);
-            // Add index for filterable fields
+            columns.push(`  ${fieldName} ${sqlType} ${nullable}`);
             if (['string', 'number'].includes(field.type)) {
-                indexes.push(`  INDEX idx_${tableName}_${field.name} (${field.name})`);
+                indexes.push(`  INDEX idx_${tableName}_${fieldName} (${fieldName})`);
             }
         }
-    });
-    // Add standard timestamp columns
+    }
     columns.push('  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP');
     columns.push('  updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
     columns.push('  deleted_at DATETIME NULL DEFAULT NULL');
-    // Add standard indexes
     indexes.push(`  INDEX idx_${tableName}_deleted_at (deleted_at)`);
     indexes.push(`  INDEX idx_${tableName}_created_at (created_at)`);
-    // Combine all parts
     const allParts = [...columns, ...indexes, ...foreignKeys];
-    const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
-    return sql;
+    return `CREATE TABLE IF NOT EXISTS ${tableName} (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
 }
 function generateDropTableSQL(tableName) {
     return `DROP TABLE IF EXISTS ${tableName};`;
 }
-function generateAddColumnSQL(tableName, field, availableModels) {
-    if (isRelationshipField(field.type, availableModels)) {
-        const foreignKeyName = getForeignKeyFieldName(field.name);
+function generateAddColumnSQL(tableName, fieldName, field, availableAggregates) {
+    if (isRelationshipField(field.type, availableAggregates)) {
+        const foreignKeyName = getForeignKeyFieldName(fieldName);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        const sqlType = 'INT';
-        return `ALTER TABLE ${tableName} ADD COLUMN ${foreignKeyName} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} ADD COLUMN ${foreignKeyName} INT ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableModels);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} ADD COLUMN ${field.name} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${sqlType} ${nullable};`;
     }
 }
 function generateDropColumnSQL(tableName, columnName) {
     return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
 }
-function generateModifyColumnSQL(tableName, field, availableModels) {
-    if (isRelationshipField(field.type, availableModels)) {
-        const foreignKeyName = getForeignKeyFieldName(field.name);
+function generateModifyColumnSQL(tableName, fieldName, field, availableAggregates) {
+    if (isRelationshipField(field.type, availableAggregates)) {
+        const foreignKeyName = getForeignKeyFieldName(fieldName);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        const sqlType = 'INT';
-        return `ALTER TABLE ${tableName} MODIFY COLUMN ${foreignKeyName} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} MODIFY COLUMN ${foreignKeyName} INT ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableModels);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} MODIFY COLUMN ${field.name} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} MODIFY COLUMN ${fieldName} ${sqlType} ${nullable};`;
     }
 }
 function loadSchemaState(stateFilePath) {
@@ -178,109 +164,93 @@ function saveMigrationLog(logFilePath, log) {
     fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
     fs.writeFileSync(logFilePath, JSON.stringify(log, null, 2));
 }
-/**
- * Sort models by dependencies so tables are created in the right order
- * (tables with no foreign keys first, then tables that depend on them)
- */
-function sortModelsByDependencies(models, availableModels) {
+function sortAggregatesByDependencies(aggregates, availableAggregates) {
     const sorted = [];
     const processed = new Set();
-    const addModel = (model) => {
-        if (processed.has(model.name))
+    const addAggregate = (name, aggregate) => {
+        if (processed.has(name))
             return;
-        // Find foreign key dependencies
-        const dependencies = [];
-        model.fields.forEach(field => {
-            if (isRelationshipField(field.type, availableModels)) {
-                dependencies.push(field.type);
-            }
-        });
-        // Add dependencies first
-        dependencies.forEach(depName => {
-            const depModel = models.find(m => m.name === depName);
-            if (depModel && !processed.has(depName)) {
-                addModel(depModel);
+        for (const [, field] of Object.entries(aggregate.fields)) {
+            if (isRelationshipField(field.type, availableAggregates)) {
+                const dep = aggregates[field.type];
+                if (dep && !processed.has(field.type)) {
+                    addAggregate(field.type, dep);
+                }
             }
-        });
-        // Then add this model
-        sorted.push(model);
-        processed.add(model.name);
+        }
+        sorted.push([name, aggregate]);
+        processed.add(name);
     };
-    models.forEach(model => addModel(model));
+    for (const [name, aggregate] of Object.entries(aggregates)) {
+        addAggregate(name, aggregate);
+    }
     return sorted;
 }
-function compareSchemas(oldState, newModels) {
+function compareSchemas(oldState, newAggregates) {
     const sqlStatements = [];
-    const availableModels = new Set(newModels.map(m => m.name));
-    if (!oldState || oldState.models.length === 0) {
-        // No previous state - generate all CREATE TABLE statements in dependency order
-        const sortedModels = sortModelsByDependencies(newModels, availableModels);
-        sortedModels.forEach(model => {
-            sqlStatements.push(`-- Create ${model.name.toLowerCase()}s table`);
-            sqlStatements.push(generateCreateTableSQL(model, availableModels));
+    const availableAggregates = new Set(Object.keys(newAggregates));
+    if (!oldState || !oldState.aggregates || Object.keys(oldState.aggregates).length === 0) {
+        const sorted = sortAggregatesByDependencies(newAggregates, availableAggregates);
+        for (const [name, aggregate] of sorted) {
+            sqlStatements.push(`-- Create ${name.toLowerCase()}s table`);
+            sqlStatements.push(generateCreateTableSQL(name, aggregate, availableAggregates));
             sqlStatements.push('');
-        });
+        }
         return sqlStatements;
     }
-    // Create maps for easy lookup
-    const oldModelsMap = new Map(oldState.models.map(m => [m.name, m]));
-    const newModelsMap = new Map(newModels.map(m => [m.name, m]));
+    const oldAggregates = oldState.aggregates;
     // Find dropped tables
-    oldState.models.forEach(oldModel => {
-        if (!newModelsMap.has(oldModel.name)) {
-            const tableName = getTableName(oldModel.name);
+    for (const oldName of Object.keys(oldAggregates)) {
+        if (!newAggregates[oldName]) {
+            const tableName = getTableName(oldName);
             sqlStatements.push(`-- Drop ${tableName} table`);
             sqlStatements.push(generateDropTableSQL(tableName));
             sqlStatements.push('');
         }
-    });
-    // Find new tables and modified tables
-    newModels.forEach(newModel => {
-        const oldModel = oldModelsMap.get(newModel.name);
-        const tableName = getTableName(newModel.name);
-        if (!oldModel) {
-            // New table
+    }
+    // Find new and modified tables
+    for (const [name, newAggregate] of Object.entries(newAggregates)) {
+        const oldAggregate = oldAggregates[name];
+        const tableName = getTableName(name);
+        if (!oldAggregate) {
             sqlStatements.push(`-- Create ${tableName} table`);
-            sqlStatements.push(generateCreateTableSQL(newModel, availableModels));
+            sqlStatements.push(generateCreateTableSQL(name, newAggregate, availableAggregates));
             sqlStatements.push('');
         }
         else {
-            // Table exists - check for column changes
-            const oldFieldsMap = new Map(oldModel.fields.map(f => [f.name, f]));
-            const newFieldsMap = new Map(newModel.fields.map(f => [f.name, f]));
+            const oldFields = oldAggregate.fields;
+            const newFields = newAggregate.fields;
             // Find dropped columns
-            oldModel.fields.forEach(oldField => {
-                if (!newFieldsMap.has(oldField.name)) {
-                    const columnName = isRelationshipField(oldField.type, availableModels)
-                        ? getForeignKeyFieldName(oldField.name)
-                        : oldField.name;
+            for (const oldFieldName of Object.keys(oldFields)) {
+                if (!newFields[oldFieldName]) {
+                    const columnName = isRelationshipField(oldFields[oldFieldName].type, availableAggregates)
+                        ? getForeignKeyFieldName(oldFieldName)
+                        : oldFieldName;
                     sqlStatements.push(`-- Drop column ${columnName} from ${tableName}`);
                     sqlStatements.push(generateDropColumnSQL(tableName, columnName));
                     sqlStatements.push('');
                 }
-            });
-            // Find new columns and modified columns
-            newModel.fields.forEach(newField => {
-                const oldField = oldFieldsMap.get(newField.name);
+            }
+            // Find new and modified columns
+            for (const [fieldName, newField] of Object.entries(newFields)) {
+                const oldField = oldFields[fieldName];
                 if (!oldField) {
-                    // New column
-                    sqlStatements.push(`-- Add column ${newField.name} to ${tableName}`);
-                    sqlStatements.push(generateAddColumnSQL(tableName, newField, availableModels));
+                    sqlStatements.push(`-- Add column ${fieldName} to ${tableName}`);
+                    sqlStatements.push(generateAddColumnSQL(tableName, fieldName, newField, availableAggregates));
                     sqlStatements.push('');
                 }
                 else {
-                    // Check if column definition changed
                     const typeChanged = oldField.type !== newField.type;
                     const requiredChanged = oldField.required !== newField.required;
                     if (typeChanged || requiredChanged) {
-                        sqlStatements.push(`-- Modify column ${newField.name} in ${tableName}`);
-                        sqlStatements.push(generateModifyColumnSQL(tableName, newField, availableModels));
+                        sqlStatements.push(`-- Modify column ${fieldName} in ${tableName}`);
+                        sqlStatements.push(generateModifyColumnSQL(tableName, fieldName, newField, availableAggregates));
                         sqlStatements.push('');
                     }
                 }
-            });
+            }
         }
-    });
+    }
     return sqlStatements;
 }
 function generateTimestamp() {

package/dist/utils/promptUtils.d.ts

@@ -0,0 +1,37 @@
+import * as readline from 'readline';
+export declare function createRl(): readline.Interface;
+/**
+ * Ask for free-form text.
+ * If allowEmpty is false (default), re-prompts until non-blank is entered.
+ */
+export declare function promptText(rl: readline.Interface, question: string, opts?: {
+    allowEmpty?: boolean;
+    defaultValue?: string;
+}): Promise<string>;
+/**
+ * Ask for a number. Re-prompts on invalid input.
+ */
+export declare function promptNumber(rl: readline.Interface, question: string, defaultValue?: number): Promise<number | undefined>;
+/**
+ * Yes/No prompt. Returns true for yes.
+ */
+export declare function promptYesNo(rl: readline.Interface, question: string, defaultYes?: boolean): Promise<boolean>;
+/**
+ * Single-select from a list of choices. Returns the chosen item.
+ */
+export declare function promptSelect<T extends {
+    label: string;
+    value: string;
+}>(rl: readline.Interface, question: string, choices: T[]): Promise<T>;
+/**
+ * Multi-select from a list of choices.
+ * User types comma-separated numbers, "all", or "none".
+ * Returns array of selected items (may be empty).
+ */
+export declare function promptMultiSelect<T extends {
+    label: string;
+    value: string;
+}>(rl: readline.Interface, question: string, choices: T[], opts?: {
+    allowNone?: boolean;
+    defaultAll?: boolean;
+}): Promise<T[]>;