@quadrel-enterprise-ui/framework 21.7.0 → 21.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@quadrel-enterprise-ui/framework",
3
- "version": "21.7.0",
3
+ "version": "21.7.1",
4
4
  "exports": {
5
5
  "./jest-preset": "./jest-preset.js",
6
6
  "./package.json": {
@@ -13855,7 +13855,12 @@ declare class QdPageStepComponent extends CdkStep implements OnInit, OnChanges,
13855
13855
  * * @note The use of CDK attributes is not permitted. Please configure this component here.
13856
13856
  */
13857
13857
  config: QdPageStepConfig;
13858
- control: AbstractControl | QdFormControl<any>;
13858
+ /**
13859
+ * The form of the step, for example a QdFormGroup.
13860
+ *
13861
+ * The stepper only moves on to the next step when this form is valid. Optional steps skip this check.
13862
+ */
13863
+ stepControl: AbstractControl;
13859
13864
  infoBanners: QueryList<QdPageInfoBannerComponent>;
13860
13865
  private _destroyed$;
13861
13866
  constructor();
@@ -13865,7 +13870,7 @@ declare class QdPageStepComponent extends CdkStep implements OnInit, OnChanges,
13865
13870
  private blockCdkInput;
13866
13871
  private validateLabel;
13867
13872
  static ɵfac: i0.ɵɵFactoryDeclaration<QdPageStepComponent, never>;
13868
- static ɵcmp: i0.ɵɵComponentDeclaration<QdPageStepComponent, "qd-page-step", never, { "config": { "alias": "config"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, {}, ["infoBanners"], ["qd-page-info-banner", "*"], true, never>;
13873
+ static ɵcmp: i0.ɵɵComponentDeclaration<QdPageStepComponent, "qd-page-step", never, { "config": { "alias": "config"; "required": false; }; "stepControl": { "alias": "stepControl"; "required": false; }; }, {}, ["infoBanners"], ["qd-page-info-banner", "*"], true, never>;
13869
13874
  }
13870
13875
 
13871
13876
  /**
@@ -19185,25 +19190,28 @@ declare class QdPageTabsModule {
19185
19190
  }
19186
19191
 
19187
19192
  /**
19188
- * @description Data Model for QdQuickEdit. Generic type defines the table columns keys.
19193
+ * All rows of a QdQuickEdit in template data mode. The generic type names the columns.
19194
+ *
19195
+ * Not used in FormArray mode, where the rows live in the consumer's form.
19189
19196
  */
19190
19197
  type QdQuickEditData<T extends string> = QdQuickEditRow<T>[];
19191
19198
  /**
19192
- * @description Type definition for QdQuickEdit data row object with its keys and values.
19199
+ * One row: a flat object whose keys are the column names.
19200
+ *
19201
+ * Flat on purpose — a column name resolves a direct key only, never a path like `address.city`.
19193
19202
  */
19194
19203
  type QdQuickEditRow<T extends string> = Record<T, QdQuickEditDataValue>;
19195
19204
  /**
19196
- * @description Type definitions for the contents of the QdQuickEdit columns.
19197
- * Currently only support for number & strings
19205
+ * What a single cell may hold. Dates and booleans are not supported.
19198
19206
  */
19199
19207
  type QdQuickEditDataValue = number | string | string[];
19200
19208
 
19201
19209
  /**
19202
- * @description Configuration model for empty state view
19210
+ * Text shown while the table holds no row at all.
19203
19211
  */
19204
19212
  interface QdQuickEditEmptyStateView {
19205
19213
  /**
19206
- * @description Toggles the empty view off, if set to "true".
19214
+ * Toggles the empty view off, if set to "true".
19207
19215
  *
19208
19216
  * * @default: false
19209
19217
  */
@@ -19218,11 +19226,14 @@ interface QdQuickEditEmptyStateView {
19218
19226
  */
19219
19227
  interface QdQuickEditConfig<T extends string> {
19220
19228
  /**
19221
- * @description Defines the columns of QuickData.
19229
+ * Defines the columns of the table, in the order they are rendered.
19230
+ *
19231
+ * Every column names a control of the row. In FormArray mode a column without a matching control
19232
+ * renders an empty cell.
19222
19233
  */
19223
19234
  columns: QdQuickEditColumn<T>[];
19224
19235
  /**
19225
- * @description Defines a list of secondary actions that can be executed per Click/Tab of an item in the menu.
19236
+ * Defines a list of secondary actions that can be executed per Click/Tab of an item in the menu.
19226
19237
  *
19227
19238
  * * @example
19228
19239
  * This is how the two actions "save" and "delete" are created.
@@ -19242,12 +19253,17 @@ interface QdQuickEditConfig<T extends string> {
19242
19253
  */
19243
19254
  secondaryActions?: QdQuickEditSecondaryAction<T>[];
19244
19255
  /**
19245
- * Determines whether users can create entries to quick edit. Works only for standalone mode. If configured as yes, a create button
19246
- * will be rendered either in quick edit itself when being used standalone. For usage in section, configure section with add button.
19256
+ * Determines whether rows can be added and removed.
19257
+ *
19258
+ * When `true`, QuickEdit renders its own create button while used standalone. Inside a section, configure the
19259
+ * section with an `addNew` action instead and leave this unset.
19260
+ *
19261
+ * **This flag also switches the remove action in the row menu on.** Without it nobody can delete a row, in
19262
+ * either mode. Adding and removing cannot be allowed separately today.
19247
19263
  */
19248
19264
  canAdd?: boolean;
19249
19265
  /**
19250
- * @description Enables a confirmation dialog before a row is removed via the built-in remove button.
19266
+ * Enables a confirmation dialog before a row is removed via the built-in remove button.
19251
19267
  *
19252
19268
  * When set to `true`, a confirmation dialog with a framework default message is shown. The row is only removed if the user confirms.
19253
19269
  * Only applies when `canAdd` is true and the remove button is visible.
@@ -19265,7 +19281,7 @@ interface QdQuickEditConfig<T extends string> {
19265
19281
  */
19266
19282
  hasRemoveConfirmation?: boolean;
19267
19283
  /**
19268
- * @description Overrides the default message of the remove confirmation dialog.
19284
+ * Overrides the default message of the remove confirmation dialog.
19269
19285
  *
19270
19286
  * When set, the confirmation dialog is shown with the provided message (setting this also enables the dialog for backward compatibility).
19271
19287
  * If omitted, the framework default message is shown when the dialog is enabled via `hasRemoveConfirmation`.
@@ -19290,11 +19306,11 @@ interface QdQuickEditConfig<T extends string> {
19290
19306
  i18n: string;
19291
19307
  };
19292
19308
  /**
19293
- * @description Sets an alternative view if no elements are available
19309
+ * Text shown instead of the table while there is no row at all.
19294
19310
  */
19295
19311
  emptyStateView?: QdQuickEditEmptyStateView;
19296
19312
  /**
19297
- * @description Enables "viewonly" mode for quick edit.
19313
+ * Enables "viewonly" mode for quick edit.
19298
19314
  *
19299
19315
  * When set to `true`, the table displays its content as read-only.
19300
19316
  * Combined with `secondaryActions`, this can be used to selectively show or hide secondary actions
@@ -19336,28 +19352,65 @@ interface QdQuickEditColumnBase<T extends string> {
19336
19352
  */
19337
19353
  isHidden?: boolean;
19338
19354
  /**
19339
- * @description Tooltip configuration for the column header.
19355
+ * Tooltip shown next to the column header.
19340
19356
  */
19341
19357
  tooltip?: QdTooltip;
19342
19358
  }
19343
19359
  /**
19344
19360
  * Column configuration for text in QdQuickEdit.
19361
+ *
19362
+ * Besides `type` it takes every field of `QdQuickEditColumnBase`: the required `name`, `i18n` and
19363
+ * `isEditable`, plus the optional `validators`, `isHidden` and `tooltip`.
19364
+ *
19365
+ * @example
19366
+ * { name: 'name', type: 'text', i18n: 'i18n.app.actors.name', isEditable: () => true }
19345
19367
  */
19346
19368
  interface QdQuickEditColumnText<T extends string> extends QdQuickEditColumnBase<T> {
19369
+ /**
19370
+ * Renders the cell as a text input.
19371
+ */
19347
19372
  type: 'text';
19348
19373
  }
19349
19374
  /**
19350
19375
  * Column configuration for integers in QdQuickEdit.
19376
+ *
19377
+ * Besides `type` it takes every field of `QdQuickEditColumnBase`: the required `name`, `i18n` and
19378
+ * `isEditable`, plus the optional `validators`, `isHidden` and `tooltip`.
19379
+ *
19380
+ * @example
19381
+ * { name: 'amount', type: 'integer', i18n: 'i18n.app.actors.amount', isEditable: () => true }
19351
19382
  */
19352
19383
  interface QdQuickEditColumnInteger<T extends string> extends QdQuickEditColumnBase<T> {
19384
+ /**
19385
+ * Renders the cell as a number input.
19386
+ */
19353
19387
  type: 'integer';
19354
19388
  }
19355
19389
  /**
19356
19390
  * Column configuration for dropdowns in QdQuickEdit.
19391
+ *
19392
+ * Besides `type` it takes every field of `QdQuickEditColumnBase`: the required `name`, `i18n` and
19393
+ * `isEditable`, plus the optional `validators`, `isHidden` and `tooltip`.
19394
+ *
19395
+ * On top of that it takes `options`, `placeholder`, `placeholderPrefix` and `filter`
19396
+ * from `QdFormDropdownConfiguration`. **`options` is required** — without it the cell renders an empty
19397
+ * dropdown. Every option carries the stored `value` and the `i18n` key shown to the user.
19398
+ *
19399
+ * @example
19400
+ * {
19401
+ * name: 'status',
19402
+ * type: 'enum',
19403
+ * i18n: 'i18n.app.actors.status',
19404
+ * isEditable: () => true,
19405
+ * options: [
19406
+ * { value: '1', i18n: 'i18n.app.actors.status.active' },
19407
+ * { value: '0', i18n: 'i18n.app.actors.status.inactive' }
19408
+ * ]
19409
+ * }
19357
19410
  */
19358
19411
  interface QdQuickEditColumnEnum<T extends string> extends QdQuickEditColumnBase<T>, Pick<QdFormDropdownConfiguration, 'placeholder' | 'placeholderPrefix' | 'filter' | 'options'> {
19359
19412
  /**
19360
- * @inheritdoc
19413
+ * Renders the cell as a dropdown. Needs `options`.
19361
19414
  */
19362
19415
  type: 'enum';
19363
19416
  }
@@ -19370,21 +19423,29 @@ type QdQuickEditColumn<T extends string> = QdQuickEditColumnInteger<T> | QdQuick
19370
19423
  */
19371
19424
  interface QdQuickEditSecondaryAction<T extends string> {
19372
19425
  /**
19373
- * @description Defines the secondary action type for the table.
19426
+ * Defines the secondary action type for the table.
19427
+ */
19428
+ /**
19429
+ * Translation key of the entry shown in the row menu.
19374
19430
  */
19375
19431
  label: {
19376
19432
  i18n: string;
19377
19433
  };
19378
19434
  /**
19379
- * @description Sets the inline action to disabled
19435
+ * Greys the entry out, either always or per row.
19436
+ *
19437
+ * The entry stays visible in the menu and cannot be clicked.
19380
19438
  */
19381
19439
  isDisabled?: boolean | ((row: QdQuickEditRow<T>) => boolean);
19382
19440
  /**
19383
- * @description Defines a handler that is triggered by a selection.
19441
+ * Runs when the user picks the entry.
19442
+ *
19443
+ * Receives the value of the row, not its position. Carry your own key in the row when you need to
19444
+ * find it again in your FormArray.
19384
19445
  */
19385
19446
  handler: (selectedRow: QdQuickEditRow<T>) => void;
19386
19447
  /**
19387
- * @description Controls in which operation mode this action is shown. May be set by the Quadrel Framework ('edit' or 'view').
19448
+ * Controls in which operation mode this action is shown. May be set by the Quadrel Framework ('edit' or 'view').
19388
19449
  *
19389
19450
  * - Use `'edit'` to show the action only in editable mode.
19390
19451
  * - Use `'view'` to show the action only in viewonly mode.
@@ -19419,25 +19480,34 @@ interface QdQuickEditSecondaryAction<T extends string> {
19419
19480
  * #### Configuration
19420
19481
  *
19421
19482
  * ```ts
19422
- * type ColumnDefinition = 'rubrik' | 'data' | 'status';
19483
+ * type ColumnDefinition = 'category' | 'amount' | 'status';
19423
19484
  * const config: QdQuickEditConfig<ColumnDefinition> = {
19424
19485
  * columns: [
19425
19486
  * {
19426
- * name: 'rubrik',
19487
+ * name: 'category',
19427
19488
  * type: 'text',
19428
- * i18n: 'translation.key.rubrik',
19489
+ * i18n: 'translation.key.category',
19429
19490
  * isEditable: () => false
19430
19491
  * },
19431
19492
  * {
19432
- * name: 'data',
19493
+ * name: 'amount',
19433
19494
  * type: 'integer',
19434
- * i18n: 'translation.key.data',
19435
- * isEditable: (row, column) => !!row['rubrik'],
19495
+ * i18n: 'translation.key.amount',
19496
+ * isEditable: row => !!row['category'],
19436
19497
  * validators: [Validators.required] // only relevant in template data mode
19498
+ * },
19499
+ * {
19500
+ * name: 'status',
19501
+ * type: 'enum',
19502
+ * i18n: 'translation.key.status',
19503
+ * isEditable: () => true,
19504
+ * options: [
19505
+ * { value: '1', i18n: 'translation.key.status.active' },
19506
+ * { value: '0', i18n: 'translation.key.status.inactive' }
19507
+ * ]
19437
19508
  * }
19438
19509
  * ],
19439
- * canAdd: true,
19440
- * secondaryActions: [...]
19510
+ * canAdd: true
19441
19511
  * }
19442
19512
  * ```
19443
19513
  *
@@ -19447,39 +19517,64 @@ interface QdQuickEditSecondaryAction<T extends string> {
19447
19517
  *
19448
19518
  * ```ts
19449
19519
  * form = new FormGroup({
19450
- * data: new FormArray([
19520
+ * rows: new FormArray([
19451
19521
  * new FormGroup({
19452
- * rubrik: new QdFormControl('Text'),
19453
- * data: new QdFormControl(123)
19522
+ * category: new QdFormControl('Text'),
19523
+ * amount: new QdFormControl(123),
19524
+ * status: new QdFormControl('1')
19454
19525
  * })
19455
19526
  * ])
19456
19527
  * })
19457
19528
  * ```
19458
19529
  *
19459
- * Then bind the `formArrayName` directive in the template:
19530
+ * Then bind the `formArrayName` directive in the template. The name is the key of your FormArray,
19531
+ * it has nothing to do with the `data` input:
19460
19532
  *
19461
19533
  * ```html
19462
19534
  * <form [formGroup]="form">
19463
- * <qd-quick-edit [config]="config" formArrayName="data"></qd-quick-edit>
19535
+ * <qd-quick-edit [config]="config" formArrayName="rows"></qd-quick-edit>
19464
19536
  * </form>
19465
19537
  * ```
19466
19538
  *
19467
- * You can add new rows by reacting to `(addNewClicked)`:
19539
+ * In this mode the FormArray is the single source of truth for the rows. QuickEdit keeps no copy of its own.
19540
+ * What the FormArray holds is what the table shows.
19541
+ *
19542
+ * **Adding rows:** QuickEdit does not create the row for you. It emits `(addNewClicked)` and you insert a new FormGroup:
19468
19543
  *
19469
19544
  * ```ts
19470
- * addControl(): void {
19471
- * this.form.get('data')?.insert(0, new FormGroup({ ... }));
19545
+ * addRow(): void {
19546
+ * this.form.controls.rows.insert(0, new FormGroup({ ... }));
19472
19547
  * }
19473
19548
  * ```
19474
19549
  *
19550
+ * **Removing rows:** QuickEdit removes the row for you. It calls `removeAt(index)` on your FormArray.
19551
+ * There is no separate output event, because the FormArray already tells you: `valueChanges` fires, `length` and `controls` are updated.
19552
+ * The remove action only appears when `canAdd` is set — that one flag switches adding and removing on together.
19553
+ * With `hasRemoveConfirmation` or `removeConfirmationMessage` in the config, a confirmation dialog is shown first.
19554
+ * The row is only removed after the user confirms.
19555
+ *
19556
+ * **Reacting to a changed set of rows:** subscribe to the FormArray, not to QuickEdit. This covers both directions,
19557
+ * rows you insert and rows QuickEdit removes:
19558
+ *
19559
+ * ```ts
19560
+ * ngOnInit(): void {
19561
+ * this.form.controls.rows.valueChanges
19562
+ * .pipe(takeUntilDestroyed(this.destroyRef))
19563
+ * .subscribe(rows => (this.rowCount = rows.length));
19564
+ * }
19565
+ * ```
19566
+ *
19567
+ * **Row actions:** an entry of `config.secondaryActions` receives the value of its row, never its position.
19568
+ * Carry your own key in the row when the handler has to find that row again in your FormArray.
19569
+ *
19475
19570
  * #### Template Data (optional)
19476
19571
  *
19477
19572
  * Alternatively, you can provide a static `data` array. This is useful for read-only scenarios without reactive forms.
19478
19573
  *
19479
19574
  * ```ts
19480
- * const data: QdQuickEditData<MyColumns> = [
19481
- * { rubrik: 'Foo', data: 42 },
19482
- * { rubrik: 'Bar', data: 77 }
19575
+ * const data: QdQuickEditData<ColumnDefinition> = [
19576
+ * { category: 'Foo', amount: 42, status: '1' },
19577
+ * { category: 'Bar', amount: 77, status: '0' }
19483
19578
  * ];
19484
19579
  * ```
19485
19580
  *
@@ -19487,6 +19582,14 @@ interface QdQuickEditSecondaryAction<T extends string> {
19487
19582
  * <qd-quick-edit [config]="config" [data]="data"></qd-quick-edit>
19488
19583
  * ```
19489
19584
  *
19585
+ * **How this mode differs:** QuickEdit builds its own FormGroup with a `rows` FormArray from the `data` input.
19586
+ * Here QuickEdit is the source of truth, not your array.
19587
+ *
19588
+ * - Adding a row: QuickEdit inserts an empty row at the top itself. `(addNewClicked)` is not emitted.
19589
+ * - Removing a row: QuickEdit removes the row from its own FormArray and also from the `data` array you passed in (in place, via `splice`).
19590
+ * - Reacting to a changed set of rows: `(formGroupChange)` emits QuickEdit's FormGroup on every change. Read the rows from `formGroup.get('rows')`.
19591
+ * - Passing a new `data` array reference rebuilds all rows from that array.
19592
+ *
19490
19593
  * #### Validation
19491
19594
  *
19492
19595
  * - In **FormArray mode**, validators must be set directly on your FormControls. Validators in `config.columns` are ignored.
@@ -19510,39 +19613,46 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
19510
19613
  private controlContainer;
19511
19614
  private confirmationDialogService;
19512
19615
  /**
19513
- * Configuration of the QuickEdit. The generic type specifies the column definition. <br />
19616
+ * Configuration of the QuickEdit. The generic type names the columns.
19514
19617
  *
19515
- * **Usage:**
19618
+ * Every column name must be a member of that type, and `name`, `type`, `i18n` and `isEditable`
19619
+ * are required on each column. The only column types are `text`, `integer` and `enum`.
19516
19620
  *
19517
19621
  * @example
19518
- * type ColumnDefinition = 'article' | 'mass' | 'documents';
19622
+ * type ColumnDefinition = 'article' | 'mass' | 'unit';
19519
19623
  * const config: QdQuickEditConfig<ColumnDefinition> = {
19520
19624
  * columns: [
19521
19625
  * {
19522
- * name: 'rubrik',
19626
+ * name: 'article',
19523
19627
  * type: 'text',
19524
- * i18n: 'translation.key.rubrik',
19628
+ * i18n: 'translation.key.article',
19525
19629
  * isEditable: () => false
19526
19630
  * },
19527
19631
  * {
19528
- * name: 'data',
19632
+ * name: 'mass',
19529
19633
  * type: 'integer',
19530
- * i18n: 'translation.key.data',
19531
- * isEditable: (row, column) => row['active'] == 1,
19532
- * validators: [Validators.required]
19634
+ * i18n: 'translation.key.mass',
19635
+ * isEditable: row => row['article'] != null,
19636
+ * validators: [Validators.required] // only applied in template data mode
19533
19637
  * },
19534
19638
  * {
19535
- * name: 'size',
19536
- * type: 'boolean',
19537
- * i18n: 'translation.key.size',
19538
- * validators: [customValidatorFunction()]
19639
+ * name: 'unit',
19640
+ * type: 'enum',
19641
+ * i18n: 'translation.key.unit',
19642
+ * isEditable: () => true,
19643
+ * options: [
19644
+ * { value: 'kg', i18n: 'translation.key.unit.kg' },
19645
+ * { value: 't', i18n: 'translation.key.unit.t' }
19646
+ * ]
19539
19647
  * }
19540
- * ]
19648
+ * ],
19649
+ * canAdd: true
19541
19650
  * }
19542
19651
  */
19543
19652
  config: QdQuickEditConfig<T>;
19544
19653
  /**
19545
- * Data provider for QuickEdit.
19654
+ * Data provider for QuickEdit. Only used in template data mode.
19655
+ * QuickEdit removes rows from this array in place. Ignored when `formArrayName` is bound.
19546
19656
  */
19547
19657
  data: QdQuickEditData<T> | undefined;
19548
19658
  get templateData(): QdQuickEditData<T>;
@@ -19555,8 +19665,13 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
19555
19665
  /**
19556
19666
  * The form group instance of QdQuickEdit.
19557
19667
  * Use this form group to bind it to step-control of QdStepper or other custom logics.
19668
+ * Only emits in template data mode. In FormArray mode your own FormArray is the source of truth.
19558
19669
  */
19559
19670
  formGroupChange: EventEmitter<any>;
19671
+ /**
19672
+ * Emitted in FormArray mode when the user clicks the add button.
19673
+ * Insert a new FormGroup into your FormArray. Not emitted in template data mode.
19674
+ */
19560
19675
  addNewClicked: EventEmitter<void>;
19561
19676
  private focusables;
19562
19677
  private customForDirective;
@@ -19570,6 +19685,9 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
19570
19685
  get canAdd(): boolean;
19571
19686
  get rows(): FormArray;
19572
19687
  get visibleColumns(): QdQuickEditColumn<T>[];
19688
+ /**
19689
+ * Track function for the column loop. Keeps a column's cells alive while the rows change.
19690
+ */
19573
19691
  trackByColumnName(_: number, column: QdQuickEditColumn<T>): string;
19574
19692
  get isFormControl(): boolean;
19575
19693
  togglerDrawing: boolean;
@@ -19577,11 +19695,37 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
19577
19695
  ngOnInit(): void;
19578
19696
  ngOnChanges(changes: SimpleChanges): void;
19579
19697
  ngOnDestroy(): void;
19698
+ /**
19699
+ * Whether a secondary action is disabled for one row.
19700
+ * Resolves the `isDisabled` of the action, which may be a flag or a function of the row.
19701
+ */
19580
19702
  isActionDisabled(action: QdQuickEditSecondaryAction<T>, row: QdQuickEditRow<T>): boolean;
19703
+ /**
19704
+ * Runs the handler of a secondary action for one row.
19705
+ * The handler receives the row value only, never its position.
19706
+ */
19581
19707
  handleSecondaryAction(action: QdQuickEditSecondaryAction<T>, rowIndex: number): void;
19708
+ /**
19709
+ * Maps a column type onto a facet component.
19710
+ *
19711
+ * @deprecated Nothing calls this any more, the template renders the cells directly. Planned for v22.
19712
+ */
19582
19713
  getComponentType(column: QdQuickEditColumn<T>): Type<unknown> | null;
19714
+ /**
19715
+ * Builds the inputs of the facet component for one cell.
19716
+ *
19717
+ * @deprecated Nothing calls this any more, the template renders the cells directly. Planned for v22.
19718
+ */
19583
19719
  getComponentInputs(column: QdQuickEditColumn<T>, row: QdQuickEditRow<T>): any;
19720
+ /**
19721
+ * Adds a row and focuses its first field.
19722
+ * FormArray mode: emits `addNewClicked` and leaves the insert to you. Template data mode: inserts an empty row at the top.
19723
+ */
19584
19724
  createRow(): void;
19725
+ /**
19726
+ * Removes the row at `index`, after the confirmation dialog when one is configured.
19727
+ * FormArray mode: calls `removeAt(index)` on your FormArray, no extra event. Template data mode: removes from the internal FormArray and from `data`.
19728
+ */
19585
19729
  removeRow(index: number): void;
19586
19730
  private executeRemoveRow;
19587
19731
  private initRows;
@@ -19625,6 +19769,11 @@ declare class QdFocusableModule {
19625
19769
  static ɵinj: i0.ɵɵInjectorDeclaration<QdFocusableModule>;
19626
19770
  }
19627
19771
 
19772
+ /**
19773
+ * Provides {@link QdQuickEditComponent} for editing rows inline.
19774
+ *
19775
+ * Import it where the table is used. It brings the form controls the cells need.
19776
+ */
19628
19777
  declare class QdQuickEditModule {
19629
19778
  static ɵfac: i0.ɵɵFactoryDeclaration<QdQuickEditModule, never>;
19630
19779
  static ɵmod: i0.ɵɵNgModuleDeclaration<QdQuickEditModule, [typeof QdQuickEditComponent, typeof QdCustomForDirective], [typeof QdCoreModule, typeof QdButtonModule, typeof i2.CommonModule, typeof QdFormModule, typeof i31.ReactiveFormsModule, typeof QdIconModule, typeof QdPopoverModule, typeof i5.TranslateModule, typeof QdPageModule, typeof QdFocusableModule, typeof QdTooltipModule], [typeof QdQuickEditComponent]>;