@ivandt/importer 1.15.4 → 1.15.6

package/dist/src/lib/types/dropdownResolver.types.d.ts

@@ -1,12 +1,12 @@
-import { DataSources, IFieldSchemaSanitised, ITableRowInternal } from '.';
+import { DataSources, IFieldSchemaSanitised, ITableRow } from '.';
 export interface IDropdownResolverWorkerMessage {
-    tableRows: ITableRowInternal[];
+    tableRows: ITableRow[];
     dropdownFields: IFieldSchemaSanitised[];
     dataSources: DataSources;
     chunkStart: number;
 }
 export interface IDropdownResolverWorkerResponse {
-    data: ITableRowInternal[];
+    data: ITableRow[];
     chunkStart: number;
     status: 'done' | 'failed';
     error?: string;

package/dist/src/lib/types/excelExport.types.d.ts

@@ -1,6 +1,6 @@
-import { IFieldSchemaSanitised, ITableRowInternal } from '.';
+import { IFieldSchemaSanitised, ITableRow } from '.';
 export interface IExcelExportWorkerMessage {
-    tableRows: ITableRowInternal[];
+    tableRows: ITableRow[];
     fieldSchemas: IFieldSchemaSanitised[];
     chunkStart: number;
 }

package/dist/src/lib/types/index.d.ts

@@ -1,9 +1,6 @@
-export * from './internal.types';
 export * from './parser.types';
 export * from './transformActions.types';
 export * from './schema.types';
-export * from './external.types';
-export * from './table.types';
 export * from './validators.types';
 export * from './cellTransformerAction.type';
 export * from './columnTransformerAction.type';

package/dist/src/lib/types/schema.types.d.ts

@@ -1,16 +1,186 @@
-import { IFieldValidatorInternal } from './validators.types';
+import { IFieldValidator, ICellError } from './validators.types';
 import { IRemoteOptionsConfig } from './remote.types';
-import { DefaultTableRowType, ITableRowsInternal } from './table.types';
-import { IFileExtension, IvtCellValue } from './internal.types';
-import { IFieldTransformerMapInternal } from './transformActions.types';
-import { IEventHandlersInternal } from './events';
-import { ICleanNumberOptions, ICombineColumnsTransformActionPayload, IFormatBooleanOptions } from './cellTransformerAction.type';
+import { IFieldTransformerMap, ITransformActionPayload, ITransformActionRunOn } from './transformActions.types';
+import { ICleanNumberOptions, ICombineColumnsTransformActionPayload, IFormatBooleanOptions, ICellTransformAction } from './cellTransformerAction.type';
 import { ILocale, ILocaleLanguage } from '.';
 import { CountryCode } from '../utils/locale';
+import { IFileInfo, IMeta } from './meta';
+import { WorkBook } from 'xlsx';
+import { IParsedSheetData } from './parser.types';
+import { IColumnTransformAction } from './columnTransformerAction.type';
+import { DetailedSettings } from 'handsontable/plugins/pagination';
+export type ITableCell = Pick<IFieldSchema, 'key' | 'type' | 'defaultValue'> & {
+    currentValue: IvtCellValue;
+    currentError: ICellError | null;
+    currentOptions?: IDropdownFieldObjectOption[];
+    newValue?: IvtCellValue;
+    newError: ICellError | null;
+    newOptions?: IDropdownFieldObjectOption[];
+};
+export type DefaultTableRowType = Record<string, IvtCellValue>;
+export type ITableRow<TableRow = DefaultTableRowType> = Record<keyof TableRow, IvtCellValue>;
+export type ITableRowChange<TableRow = DefaultTableRowType> = Record<keyof TableRow, ITableCell>;
+export type ITableRows<TableRow = DefaultTableRowType> = ITableRow<TableRow>[];
+export interface FieldSchemaMap {
+    dropdown: IDropdownFieldSchema;
+    phone: IPhoneFieldSchema;
+    monetary: IMonetaryFieldSchema;
+    checkbox: ICheckBoxFieldSchema;
+    date: IDateFieldSchema;
+    numeric: INumericFieldSchema;
+    password: IPasswordFieldSchema;
+    text: ITextFieldSchema;
+    time: ITimeFieldSchema;
+    combine: ICombineFiledSchema;
+}
+export interface IFileHeader {
+    label: string;
+    key: string;
+    order: number;
+}
+export interface IFieldMapping {
+    field: IFieldSchema;
+    file: IFileHeader | null;
+    perfectMatch: boolean;
+    guessMatch: boolean;
+    aiMatch: boolean;
+    manualMatch: boolean;
+    hiddenInMappingStage: boolean;
+    hiddenInReviewState: boolean;
+}
+export interface IFieldMappingSanitised {
+    field: IFieldSchemaSanitised;
+    file: IFileHeader | null;
+    perfectMatch: boolean;
+    guessMatch: boolean;
+    aiMatch: boolean;
+}
+export type IHotCellEditChange = [
+    number,
+    string,
+    IvtCellValue,
+    IvtCellValue
+];
+export type IHotCellUpdateChange = [
+    number,
+    string,
+    IvtCellValue
+];
+export type ISimpleOption = {
+    label: string;
+    value: string;
+};
+export type IFieldSchemaSanitised<TSchema extends IFieldSchema = IFieldSchema> = Pick<TSchema, 'validators' | 'key' | 'order' | 'label' | 'type' | 'transformers'> & Partial<Pick<IBaseFieldSchema, 'alternativeMatches'>> & Partial<Pick<IMenuFieldSchema, 'options' | 'acceptNewValueIfNoOptions'>>;
+export type IFieldMappings = IFieldMapping[];
+export type IFileStore = {
+    fileHeaders: IFileHeader[];
+    workBook: WorkBook | null;
+};
+export interface ICellErrorWithMeta<TableRow = DefaultTableRowType> {
+    row: number;
+    fieldKey: keyof TableRow;
+    col: number;
+    error: ICellError;
+}
+export interface IValidatorWorkerResponse {
+    errors: ICellErrorWithMeta[];
+    status: 'in-progress' | 'done' | 'failed';
+    error?: string;
+    progress?: {
+        inc: number;
+        total: number;
+    };
+}
+export interface IActionWorkerResponse {
+    data: ITableRows;
+    status: 'done' | 'failed';
+}
+export interface ITransformerWorkerResponse {
+    data: ITableRows;
+    chunkStart: number;
+    status: 'done' | 'failed';
+}
+export type FuzzyIndexes = Map<string, string>;
+export interface IValidatorWorkerMessage {
+    rowRange: ITableRowRange;
+    tableRows: ITableRow[];
+    dataSource: DataSources;
+    tableRowsStartIndex: number;
+    fieldSchemas: IFieldSchemaSanitised[];
+}
+export interface ITableRowRange {
+    startRowIndex: number;
+    rowsLength: number;
+}
+export interface IValidateCellChangesData {
+    changes: IHotCellEditChange[];
+    tableRows: ITableRows;
+    dataSource?: DataSources;
+    fieldSchemas: IFieldSchemaSanitised[];
+}
+export interface IActionWorkerMessage {
+    tableRows: ITableRows;
+    hiddenRows: number[];
+    cellErrors: ICellErrorWithMeta[];
+    action: IColumnTransformAction | ICellTransformAction;
+    payload: ITransformActionPayload;
+    dataSources: DataSources;
+}
+export interface IMappingWorkerResponse {
+    tableRows: ITableRows;
+    status: 'done' | 'failed';
+    error?: string;
+}
+export interface IMappingWorkerMessage {
+    fieldMappings: IFieldMappingSanitised[];
+    sheetData: IParsedSheetData['rows'];
+}
+export interface ITransformerTableWorkerMessage {
+    tableRows: ITableRows;
+    hiddenRows: number[];
+    chunkStart: number;
+    dataSources: DataSources;
+    cellErrors: ICellErrorWithMeta[];
+    runOns: ITransformActionRunOn[];
+    fieldSchemas: IFieldSchemaSanitised[];
+}
+export type IToastMessage = {
+    id?: string;
+    title?: string;
+    message?: string;
+    type: 'info' | 'error' | 'warning' | 'success';
+    dismissible?: boolean;
+    timeout?: number;
+};
+export type IFileExtension = 'xls' | 'xlsx' | 'csv' | 'pdf' | 'json' | 'txt' | 'xml' | 'unknown';
+export type IvtCellValue = string | number | Date | null | undefined | boolean | IDropdownFieldObjectOption;
+export type ISearchColumnResult = {
+    row: number;
+    column: number;
+    cellValue: string;
+};
+export type IActiveBadge = 'valid' | 'warning' | 'invalid' | 'all' | 'duplicate';
+export type IRowRange = 'all' | 'errors' | 'warnings' | 'valids' | 'duplicates';
+export type CreateImportRequest = {
+    rows: ITableRows;
+    meta: IMeta;
+    originalSchema: IvtSchema;
+};
+export interface CreateImportResponse {
+    id: string;
+    templateId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    originalFileUrl: string | null;
+    meta: IMeta;
+}
+export type PaginationProps = Required<Omit<DetailedSettings, 'uiContainer' | 'pageSize'>> & {
+    pageSize: number;
+};
 export type IFieldSchemaType = 'dropdown' | 'checkbox' | 'date' | 'numeric' | 'monetary' | 'password' | 'text' | 'combine' | 'time' | 'phone';
-export interface IBaseFieldSchemaInternal {
-    validators?: IFieldValidatorInternal[];
-    transformers?: IFieldTransformerMapInternal[];
+export interface IBaseFieldSchema<TableRow = DefaultTableRowType> {
+    validators?: IFieldValidator<TableRow>[];
+    transformers?: IFieldTransformerMap[];
     type: IFieldSchemaType;
     label: string;
     key: string;
@@ -24,12 +194,12 @@ export interface IBaseFieldSchemaInternal {
     defaultValue?: IvtCellValue;
     onChange?: (rowNumber: number, oldValue: string, newValue: string) => void;
 }
-export interface ICheckBoxFieldSchemaInternal extends Omit<IBaseFieldSchemaInternal, 'defaultValue'> {
+export interface ICheckBoxFieldSchema extends Omit<IBaseFieldSchema, 'defaultValue'> {
     type: 'checkbox';
     defaultValue?: boolean;
     autoClean?: false | IFormatBooleanOptions;
 }
-export interface IDateFieldSchemaInternal extends Omit<IBaseFieldSchemaInternal, 'defaultValue'> {
+export interface IDateFieldSchema extends Omit<IBaseFieldSchema, 'defaultValue'> {
     type: 'date';
     defaultValue?: Date | string;
     formatPattern: string;
@@ -40,13 +210,13 @@ export interface IFormatDateAutoCleanOptions {
     parsePatterns?: string[];
     strictParsing?: boolean;
 }
-export interface INumericFieldSchemaInternal extends Omit<IBaseFieldSchemaInternal, 'defaultValue'> {
+export interface INumericFieldSchema extends Omit<IBaseFieldSchema, 'defaultValue'> {
     type: 'numeric';
     defaultValue?: number;
     locale?: ILocale;
     autoClean?: false | Omit<ICleanNumberOptions, 'locale'>;
 }
-export interface IMonetaryFieldSchemaInternal<TableRow = DefaultTableRowType> extends Omit<IBaseFieldSchemaInternal, 'defaultValue'> {
+export interface IMonetaryFieldSchema<TableRow = DefaultTableRowType> extends Omit<IBaseFieldSchema, 'defaultValue'> {
     type: 'monetary';
     locale?: ILocale | {
         fieldKey: keyof TableRow;
@@ -61,33 +231,33 @@ export interface IMonetaryFieldSchemaInternal<TableRow = DefaultTableRowType> ex
     };
     defaultValue?: number;
 }
-export interface IPasswordFieldSchemaInternal extends IBaseFieldSchemaInternal {
+export interface IPasswordFieldSchema extends IBaseFieldSchema {
     type: 'password';
     defaultValue?: string;
 }
-export interface IDropdownFieldSchemaInternal extends IBaseFieldSchemaInternal {
+export interface IDropdownFieldSchema extends IBaseFieldSchema {
     type: 'dropdown';
-    options: IDataSourceResolver | IRemoteOptionsConfig;
+    options: string[] | IDropdownFieldObjectOption[] | IDataSourceResolver | IRemoteOptionsConfig;
     acceptNewValueIfNoOptions?: boolean;
 }
 export type IDropdownFieldObjectOption = {
     label: string;
     value: string;
 };
-export interface ITextFieldSchemaInternal extends IBaseFieldSchemaInternal {
+export interface ITextFieldSchema extends IBaseFieldSchema {
     type: 'text';
     defaultValue?: string;
 }
-export interface ICombineFiledSchemaInternal extends Omit<IBaseFieldSchemaInternal, 'alternativeMatches'> {
+export interface ICombineFiledSchema extends Omit<IBaseFieldSchema, 'alternativeMatches'> {
     type: 'combine';
     combine: Omit<ICombineColumnsTransformActionPayload, 'fieldSchemas' | 'columnNumber'>;
     defaultValue?: string;
 }
-export interface ITimeFieldSchemaInternal extends IBaseFieldSchemaInternal {
+export interface ITimeFieldSchema extends IBaseFieldSchema {
     type: 'time';
 }
 /**
- * IPhoneFieldSchemaInternal
+ * IPhoneFieldSchema
  * Field for phone numbers with automatic validation and formatting.
  *
  * The SDK automatically adds:
@@ -97,7 +267,7 @@ export interface ITimeFieldSchemaInternal extends IBaseFieldSchemaInternal {
  * Phone numbers are validated against allowed countries using libphonenumber-js.
  * The transformer cleans and formats numbers consistently based on withInternationalCode setting.
  * */
-export interface IPhoneFieldSchemaInternal extends IBaseFieldSchemaInternal {
+export interface IPhoneFieldSchema extends IBaseFieldSchema {
     type: 'phone';
     /**
      * countries
@@ -160,61 +330,75 @@ export type DataSources = Record<string, any>;
 export interface IDataSourceResolver {
     query: string;
 }
-export type IMenuFieldSchemaInternal = IDropdownFieldSchemaInternal;
-export type IFieldSchemaInternal = IMenuFieldSchemaInternal | ICheckBoxFieldSchemaInternal | IDateFieldSchemaInternal | INumericFieldSchemaInternal | IMonetaryFieldSchemaInternal | IPasswordFieldSchemaInternal | ITextFieldSchemaInternal | ICombineFiledSchemaInternal | ITimeFieldSchemaInternal | IPhoneFieldSchemaInternal;
-export type IvtSchemaInternal = {
+export type IMenuFieldSchema = IDropdownFieldSchema;
+export type IFieldSchema = IMenuFieldSchema | ICheckBoxFieldSchema | IDateFieldSchema | INumericFieldSchema | IMonetaryFieldSchema | IPasswordFieldSchema | ITextFieldSchema | ICombineFiledSchema | ITimeFieldSchema | IPhoneFieldSchema;
+export type IvtSchema<TableRow = DefaultTableRowType> = {
     id?: string;
     title: string;
     key: string;
-    dataSources: DataSources;
-    fields: IFieldSchemaInternal[];
+    dataSources?: DataSources;
+    fields: IFieldSchema[];
     publicKey: string;
     sessionToken: string;
-    initialData?: ITableRowsInternal;
+    initialData?: ITableRows;
     initialFile?: File;
     environment?: 'local' | 'dev' | 'staging' | 'prod';
-    eventHandlers?: IEventHandlersInternal;
-    stepsConfig: {
-        uploadFileStep: {
-            title: string;
-            subTitle: string;
-            supportedExtensions: IFileExtension[];
-            dataEntryMethod: 'manual' | 'upload' | 'manual_and_upload';
-            maxColumns: number;
-            maxRows: number;
-            maxFileSize: number;
+    eventHandlers?: {
+        onBeforeRowsChange?: (changedTableRows: ITableRowChange<TableRow>[], range: ITableRowRange, fullTableRows: ITableRows<TableRow>) => Promise<{
+            changedRows: ITableRowChange<TableRow>[];
+        }>;
+        onSubmit?: (tableRows: ITableRows<TableRow>, meta: IMeta, cellErrors: ICellErrorWithMeta[], submitMeta: CreateImportResponse | null) => Promise<void>;
+        onExport?: (tableRows: ITableRows<TableRow>, meta: IMeta, cellErrors: ICellErrorWithMeta[]) => Promise<void>;
+        onSubmitError?: (error: any) => void;
+        onSubmitCancel?: () => void;
+        onFileUpload?: (file: File, fileMeta: IFileInfo) => void;
+        onReady?: (rootElement: HTMLElement) => void;
+        onCancelImporter?: () => void;
+    };
+    stepsConfig?: {
+        uploadFileStep?: {
+            title?: string;
+            subTitle?: string;
+            supportedExtensions?: IFileExtension[];
+            dataEntryMethod?: 'manual' | 'upload' | 'manual_and_upload';
+            maxColumns?: number;
+            maxRows?: number;
+            maxFileSize?: number;
+        };
+        mapHeadersStep?: {
+            title?: string;
+            subTitle?: string;
+            passThroughExcessColumns?: boolean;
+            unMatchedHeadersBehaviour?: 'block' | 'allow' | 'warn';
+            intelligentImport?: boolean;
         };
-        mapHeadersStep: {
-            title: string;
-            subTitle: string;
-            passThroughExcessColumns: boolean;
-            unMatchedHeadersBehaviour: 'block' | 'allow' | 'warn';
-            intelligentImport: boolean;
+        chooseSheetStep?: {
+            title?: string;
+            subTitle?: string;
         };
-        chooseSheetStep: {
-            title: string;
-            subTitle: string;
+        mapFieldsStep?: {
+            title?: string;
+            subTitle?: string;
+            intelligentFieldMapping?: boolean;
         };
-        mapFieldsStep: {
-            title: string;
-            subTitle: string;
-            intelligentFieldMapping: boolean;
+        reviewStep?: {
+            title?: string;
+            subTitle?: string;
+            invalidDataBehaviour?: 'block_submit' | 'remove_invalid_rows' | 'include_invalid_rows';
+            storeInIvandtServer?: boolean;
+            allowCustomColumn?: boolean;
+            allowSubmitCancel?: boolean;
+            pagination?: boolean | IPaginationOptions;
         };
-        reviewStep: {
-            title: string;
-            subTitle: string;
-            invalidDataBehaviour: 'block_submit' | 'remove_invalid_rows' | 'include_invalid_rows';
-            storeInIvandtServer: boolean;
-            allowCustomColumn: boolean;
-            allowSubmitCancel: boolean;
-            pagination: boolean | IPaginationOptions;
+        shared?: {
+            withCancelButton?: boolean;
         };
     };
-    advanced: {
-        maxInMemoryValidationRows: number;
-        maxPerWorkerValidationRows: number;
-        maxInMemoryTransformationRows: number;
-        maxPerWorkerTransformationRows: number;
+    advanced?: {
+        maxInMemoryValidationRows?: number;
+        maxPerWorkerValidationRows?: number;
+        maxInMemoryTransformationRows?: number;
+        maxPerWorkerTransformationRows?: number;
     };
     locale?: ILocaleLanguage;
 };

package/dist/src/lib/types/transformActions.types.d.ts

@@ -1,6 +1,6 @@
-import { IFieldSchemaSanitised } from './internal.types';
 import { ColumnActionPayloadMap, IColumnTransformActionPayload } from './columnTransformerAction.type';
 import { CellActionPayloadMap, ICellTransformActionPayload } from './cellTransformerAction.type';
+import { IFieldSchemaSanitised } from './schema.types';
 export type ITransformActionRunOn = 'load' | 'cells-change';
 export interface ITransformActionPayloadBase {
     runOns?: ITransformActionRunOn[];
@@ -8,16 +8,34 @@ export interface ITransformActionPayloadBase {
     fieldSchemas: IFieldSchemaSanitised[];
 }
 export type ITransformActionPayload = IColumnTransformActionPayload | ICellTransformActionPayload;
-export type ICellFieldTransformerMapInternal = {
-    [A in keyof CellActionPayloadMap]: {
-        action: A;
-        payload: Omit<CellActionPayloadMap[A], 'columnNumber' | 'fieldSchemas'>;
-    };
+/**
+ * Extract required keys from a type.
+ * Returns `never` if all keys are optional (or type is empty).
+ */
+type RequiredKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? never : K;
+}[keyof T];
+/**
+ * The user-facing payload type (internal fields stripped out).
+ */
+type UserPayload<T> = Omit<T, 'columnNumber' | 'fieldSchemas'>;
+/**
+ * Build a transformer map entry where:
+ * - If the payload has required keys → `payload` is required
+ * - If the payload has NO required keys (all optional or empty) → `payload` is optional
+ */
+type TransformerMapEntry<A, P> = RequiredKeys<UserPayload<P>> extends never ? {
+    action: A;
+    payload?: UserPayload<P>;
+} : {
+    action: A;
+    payload: UserPayload<P>;
+};
+export type ICellFieldTransformerMap = {
+    [A in keyof CellActionPayloadMap]: TransformerMapEntry<A, CellActionPayloadMap[A]>;
 }[keyof CellActionPayloadMap];
-export type IColumnFieldTransformerMapInternal = {
-    [A in keyof ColumnActionPayloadMap]: {
-        action: A;
-        payload: Omit<ColumnActionPayloadMap[A], 'columnNumber' | 'fieldSchemas'>;
-    };
+export type IColumnFieldTransformerMap = {
+    [A in keyof ColumnActionPayloadMap]: TransformerMapEntry<A, ColumnActionPayloadMap[A]>;
 }[keyof ColumnActionPayloadMap];
-export type IFieldTransformerMapInternal = IColumnFieldTransformerMapInternal | ICellFieldTransformerMapInternal;
+export type IFieldTransformerMap = IColumnFieldTransformerMap | ICellFieldTransformerMap;
+export {};

package/dist/src/lib/types/validators.types.d.ts

@@ -1,11 +1,10 @@
 import { IsCreditCardOptions } from 'validator';
-import { DefaultTableRowType, ITableRowInternal } from './table.types';
+import { DefaultTableRowType, ITableRow, IFormatDateAutoCleanOptions } from './schema.types';
 import { IsURLOptions } from 'validator/lib/isURL';
 import { Rule } from '@ivandt/json-rules';
 import { ICleanNumberOptions, IFormatBooleanOptions, IGenerateUUIDsTransformActionPayload, IsEmailOptions } from './cellTransformerAction.type';
 import { CountryCode } from '../utils/locale';
 import { ILocale } from './locale';
-import { IFormatDateAutoCleanOptions } from './schema.types';
 export type IFieldValidatorType = 'required' | 'rules' | 'uuid' | 'numeric' | 'boolean' | 'unique' | 'regex' | 'email' | 'min' | 'max' | 'range' | 'minLength' | 'maxLength' | 'url' | 'phone' | 'date' | 'enumerate' | 'creditcard' | 'custom';
 /**
  * Severity level for validation errors.
@@ -14,7 +13,7 @@ export type IFieldValidatorType = 'required' | 'rules' | 'uuid' | 'numeric' | 'b
  * - 'w' (warning): Marks the cell with an orange warning indicator. Does not block submission. Useful for optional fields where data would be beneficial but not required.
  */
 export type IErrorSeverity = 'w' | 'e';
-export type IFieldValidatorValidate = (cellValue: string, rowData?: ITableRowInternal) => ICellError | Promise<ICellError>;
+export type IFieldValidatorValidate = (cellValue: string, rowData?: ITableRow) => ICellError | Promise<ICellError>;
 export interface IBaseFieldValidator {
     type: IFieldValidatorType;
     message?: string;
@@ -29,7 +28,7 @@ export interface ICellError {
     /**
      * The type of validator that produced this error, or null if validation passed.
      */
-    type: IFieldValidatorInternal['type'] | null;
+    type: IFieldValidator['type'] | null;
     /**
      * Severity level of the error.
      * - 'e': Error that blocks submission or removes the row.
@@ -231,7 +230,7 @@ export interface IBooleanFieldValidator extends IBaseFieldValidator {
  * }
  * ```
  */
-export interface IUniqueFieldValidatorInternal extends IBaseFieldValidator {
+export interface IUniqueFieldValidator extends IBaseFieldValidator {
     /**
      * Validator type identifier.
      * @constant 'unique'
@@ -242,7 +241,7 @@ export interface IUniqueFieldValidatorInternal extends IBaseFieldValidator {
      * Key is the cell value, value is the count of occurrences.
      * @internal
      */
-    valueCounts: Record<string, number>;
+    valueCounts?: Record<string, number>;
 }
 /**
  * Validates that a field matches a specified regular expression pattern.
@@ -633,13 +632,13 @@ export interface ICustomFieldValidator extends IBaseFieldValidator {
      */
     validate: IFieldValidatorValidate;
 }
-export type IFieldValidatorInternal = IRequiredFieldValidator | IRulesFieldValidator | IUUIDFieldValidator | INumericFieldValidator | IBooleanFieldValidator | IUniqueFieldValidatorInternal | IRegexFieldValidator | IEmailFieldValidator | IMinFieldValidator | IMaxFieldValidator | IRangeFieldValidator | IMinLengthFieldValidator | IMaxLengthFieldValidator | IUrlFieldValidator | IPhoneFieldValidator | IDateFieldValidator | IEnumerateFieldValidator | ICreditCardFieldValidator | ICustomFieldValidator;
+export type IFieldValidator<TableRow = DefaultTableRowType> = IRequiredFieldValidator | IRulesFieldValidator<TableRow> | IUUIDFieldValidator | INumericFieldValidator | IBooleanFieldValidator | IUniqueFieldValidator | IRegexFieldValidator | IEmailFieldValidator | IMinFieldValidator | IMaxFieldValidator | IRangeFieldValidator | IMinLengthFieldValidator | IMaxLengthFieldValidator | IUrlFieldValidator | IPhoneFieldValidator | IDateFieldValidator | IEnumerateFieldValidator | ICreditCardFieldValidator | ICustomFieldValidator;
 export interface IFieldValidatorMap {
     required: IRequiredFieldValidator;
     rules: IRulesFieldValidator;
     numeric: INumericFieldValidator;
     boolean: IBooleanFieldValidator;
-    unique: IUniqueFieldValidatorInternal;
+    unique: IUniqueFieldValidator;
     regex: IRegexFieldValidator;
     email: IEmailFieldValidator;
     min: IMinFieldValidator;

package/dist/src/lib/utils/augmentCellChangesWithTableRows.d.ts

@@ -1,4 +1,4 @@
-import { IHotCellEditChange, ITableRowInternal, ITableRowRange } from '../types';
+import { IHotCellEditChange, ITableRows, ITableRowRange } from '../types';
 /**
  * Extracts and merges a contiguous slice of table rows based on a set of cell edits.
  *
@@ -15,7 +15,7 @@ import { IHotCellEditChange, ITableRowInternal, ITableRowRange } from '../types'
  *   - `augmentedRows`: The merged row objects for every index from the first change to the last.
  *   - `range`: An object `{ startRowIndex, rowsLength }` describing the slice of rows extracted.
  */
-export declare function augmentCellChangesWithTableRows(changes: IHotCellEditChange[], tableRows: ITableRowInternal[]): {
-    augmentedRows: ITableRowInternal[];
+export declare function augmentCellChangesWithTableRows(changes: IHotCellEditChange[], tableRows: ITableRows): {
+    augmentedRows: ITableRows;
     range: ITableRowRange;
 };

package/dist/src/lib/utils/augmentChangesForCrossFieldValidation.d.ts

@@ -1,2 +1,2 @@
-import { IFieldMappings, IHotCellEditChange, ITableRowInternal } from '../types';
-export declare function augmentChangesForCrossColumnValidation(changes: IHotCellEditChange[], fieldMappings: IFieldMappings, tableRows: ITableRowInternal[]): IHotCellEditChange[];
+import { IFieldMappings, IHotCellEditChange, ITableRows } from '../types';
+export declare function augmentChangesForCrossColumnValidation(changes: IHotCellEditChange[], fieldMappings: IFieldMappings, tableRows: ITableRows): IHotCellEditChange[];

package/dist/src/lib/utils/createField.d.ts

@@ -1,2 +1,2 @@
-import { FieldSchemaMapInternal, IFieldSchemaType } from '../types';
-export declare function createField<T extends IFieldSchemaType>(type: T, field: Omit<FieldSchemaMapInternal[T], 'type'>): FieldSchemaMapInternal[T];
+import { FieldSchemaMap, IFieldSchemaType } from '../types';
+export declare function createField<T extends IFieldSchemaType>(type: T, field: Omit<FieldSchemaMap[T], 'type'>): FieldSchemaMap[T];

package/dist/src/lib/utils/extractFieldKeysFromTemplate.d.ts

@@ -1,4 +1,4 @@
-import { IFieldMappings, IFieldSchemaInternal, ICellTransformAction } from '../types';
+import { IFieldMappings, IFieldSchema, ICellTransformAction } from '../types';
 /**
  * Extracts all field keys from a combine template string.
  * Template format: "Hello {firstName} {lastName}"
@@ -8,9 +8,12 @@ export declare function extractFieldKeysFromTemplate(template: string): string[]
 /**
  * Gets the combine transformer from a field schema if it exists.
  */
-export declare function getCombineTransformer(field: IFieldSchemaInternal): {
+export declare function getCombineTransformer(field: IFieldSchema): {
     action: ICellTransformAction.CombineColumns;
-    payload: Omit<import('../types').ICombineColumnsTransformActionPayload, "columnNumber" | "fieldSchemas">;
+    payload: {
+        runOns?: import('../types').ITransformActionRunOn[] | undefined;
+        template: string;
+    };
 } | undefined;
 /**
  * Extracts all field keys used in combine transformers across all field mappings.

package/dist/src/lib/utils/getAllPossibleOptions.d.ts

@@ -1,2 +1,2 @@
-import { IFieldSchemaInternal } from '../types';
-export declare function getAllPossibleOptions(fieldSchema: IFieldSchemaInternal): string[];
+import { IFieldSchema } from '../types';
+export declare function getAllPossibleOptions(fieldSchema: IFieldSchema): string[];

package/dist/src/lib/utils/getVisibleFieldSchemas.d.ts

@@ -1,2 +1,2 @@
-import { IFieldSchemaInternal } from '../types';
-export declare function getVisibleFieldSchemas(): IFieldSchemaInternal[];
+import { IFieldSchema } from '../types';
+export declare function getVisibleFieldSchemas(): IFieldSchema[];

package/dist/src/lib/utils/hasCalculatedField.d.ts

@@ -1,3 +1,3 @@
-import { IFieldMappings, IFieldSchemaInternal } from '../types';
+import { IFieldMappings, IFieldSchema } from '../types';
 export declare const hasCalculatedField: (fieldMappings: IFieldMappings) => boolean;
-export declare const hasCalculatedTransformer: (field: IFieldSchemaInternal) => boolean;
+export declare const hasCalculatedTransformer: (field: IFieldSchema) => boolean;

package/dist/src/lib/utils/hot/convertHotDataToIngTableRows.d.ts

@@ -1,2 +1,2 @@
-import { IFieldSchemaSanitised, ITableRowsInternal, IvtCellValue } from '../../types';
-export declare const convertHotDataToIngTableRows: (hotData: IvtCellValue[][], fieldSchemas: IFieldSchemaSanitised[]) => ITableRowsInternal;
+import { IFieldSchemaSanitised, ITableRows, IvtCellValue } from '../../types';
+export declare const convertHotDataToIngTableRows: (hotData: IvtCellValue[][], fieldSchemas: IFieldSchemaSanitised[]) => ITableRows;

package/dist/src/lib/utils/hot/convertTableRowsToHotCellChanges.d.ts

@@ -1,2 +1,2 @@
-import { IHotCellUpdateChange, ITableRowInternal, ITableRowRange } from '../../types';
-export declare function convertTableRowsToHotCellChanges(transformedTableRows: ITableRowInternal[], range: ITableRowRange): IHotCellUpdateChange[];
+import { IHotCellUpdateChange, ITableRows, ITableRowRange } from '../../types';
+export declare function convertTableRowsToHotCellChanges(transformedTableRows: ITableRows, range: ITableRowRange): IHotCellUpdateChange[];

package/dist/src/lib/utils/hot/convertTableRowsToHotData.d.ts

@@ -1,2 +1,2 @@
-import { IFieldSchemaSanitised, ITableRowsInternal, IvtCellValue } from '../../types';
-export declare const convertTableRowsToHotData: (tableRows: ITableRowsInternal, fieldSchemas: IFieldSchemaSanitised[]) => IvtCellValue[][];
+import { IFieldSchemaSanitised, ITableRows, IvtCellValue } from '../../types';
+export declare const convertTableRowsToHotData: (tableRows: ITableRows, fieldSchemas: IFieldSchemaSanitised[]) => IvtCellValue[][];

package/dist/src/lib/utils/initialData/generateEmptyRows.d.ts

@@ -1,4 +1,4 @@
-import { IFieldSchemaInternal, ITableRowsInternal } from '../../types';
+import { IFieldSchema, ITableRows } from '../../types';
 /**
  * Generates empty rows for manual data entry
  * Each row contains all field keys with null values
@@ -6,4 +6,4 @@ import { IFieldSchemaInternal, ITableRowsInternal } from '../../types';
  * @param count - Number of empty rows to generate (default: 100)
  * @returns Array of empty table rows
  */
-export declare function generateEmptyRows(fields: IFieldSchemaInternal[], count?: number): ITableRowsInternal;
+export declare function generateEmptyRows(fields: IFieldSchema[], count?: number): ITableRows;