datera 0.1.0

package/dist/config/schema.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etlConfigSchema = void 0;
+const zod_1 = require("zod");
+const ioSchema_1 = require("./ioSchema");
+const mergeSchema_1 = require("./mergeSchema");
+const prepareSchema_1 = require("./prepareSchema");
+const validationSchema_1 = require("./validationSchema");
+exports.etlConfigSchema = zod_1.z
+    .object({
+    source: ioSchema_1.sourceSchema.optional(),
+    destination: ioSchema_1.destinationSchema.optional(),
+    tableName: zod_1.z.string().optional(),
+    spreadsheetId: zod_1.z.string().optional(),
+    credentialsPath: zod_1.z.string().optional(),
+    mode: zod_1.z.enum(["raw", "dedupe", "merge"]),
+    dbHost: zod_1.z.string().optional(),
+    dbPort: zod_1.z.number().optional(),
+    dbUser: zod_1.z.string().optional(),
+    dbPassword: zod_1.z.string().optional(),
+    dbName: zod_1.z.string().optional(),
+    dedupeColumn: zod_1.z.string().optional(),
+    dedupeStrategy: zod_1.z.enum(["keep-first", "keep-last"]).optional(),
+    dedupeKeyNormalizer: zod_1.z.string().optional(),
+    mergeKeyColumn: zod_1.z.string().optional(),
+    mergeColumns: zod_1.z.array(mergeSchema_1.mergeColumnSchema).optional(),
+    mergeEmptyKeyLabel: zod_1.z.string().optional(),
+    mergeRejectedKeyLabel: zod_1.z.string().optional(),
+    mergeKeyNormalizer: zod_1.z.string().optional(),
+    normalizerModules: zod_1.z.array(zod_1.z.string()).optional(),
+    adapterModules: zod_1.z.array(zod_1.z.string()).optional(),
+    fillEmpty: zod_1.z.array(prepareSchema_1.fillEmptySchema).optional(),
+    combineColumns: zod_1.z.array(prepareSchema_1.combineColumnsSchema).optional(),
+    validation: validationSchema_1.validationSchema.optional(),
+})
+    .refine((config) => config.source !== undefined || config.tableName !== undefined, {
+    message: 'Faltou dizer de onde ler: coloque "source" ou os campos antigos do MySQL.',
+    path: ["source"],
+})
+    .refine((config) => config.destination !== undefined ||
+    config.spreadsheetId !== undefined, {
+    message: 'Faltou dizer onde escrever: coloque "destination" ou o "spreadsheetId".',
+    path: ["destination"],
+});

package/dist/config/validationSchema.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const validationSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        column: z.ZodString;
+        rule: z.ZodLiteral<"required">;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        column: z.ZodString;
+        rule: z.ZodLiteral<"pattern">;
+        pattern: z.ZodString;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        column: z.ZodString;
+        rule: z.ZodLiteral<"oneOf">;
+        values: z.ZodArray<z.ZodString>;
+        ignoreCase: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        column: z.ZodString;
+        rule: z.ZodLiteral<"normalizer">;
+        normalizer: z.ZodString;
+    }, z.core.$strip>], "rule">>;
+    pendingSheet: z.ZodOptional<z.ZodString>;
+    reasonColumn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/config/validationSchema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationSchema = void 0;
+const zod_1 = require("zod");
+const ruleMessage = { message: zod_1.z.string().optional() };
+const validationRuleSchema = zod_1.z.discriminatedUnion("rule", [
+    zod_1.z.object({
+        column: zod_1.z.string(),
+        rule: zod_1.z.literal("required"),
+        ...ruleMessage,
+    }),
+    zod_1.z
+        .object({
+        column: zod_1.z.string(),
+        rule: zod_1.z.literal("pattern"),
+        pattern: zod_1.z.string(),
+        flags: zod_1.z.string().optional(),
+        ...ruleMessage,
+    })
+        .refine((value) => {
+        try {
+            new RegExp(value.pattern, value.flags);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, {
+        message: "pattern não é uma expressão regular válida.",
+        path: ["pattern"],
+    }),
+    zod_1.z.object({
+        column: zod_1.z.string(),
+        rule: zod_1.z.literal("oneOf"),
+        values: zod_1.z.array(zod_1.z.string()).min(1),
+        ignoreCase: zod_1.z.boolean().optional(),
+        ...ruleMessage,
+    }),
+    zod_1.z.object({
+        column: zod_1.z.string(),
+        rule: zod_1.z.literal("normalizer"),
+        normalizer: zod_1.z.string(),
+        ...ruleMessage,
+    }),
+]);
+exports.validationSchema = zod_1.z.object({
+    rules: zod_1.z.array(validationRuleSchema).min(1),
+    pendingSheet: zod_1.z.string().min(1).optional(),
+    reasonColumn: zod_1.z.string().min(1).optional(),
+});

package/dist/env.d.ts

@@ -0,0 +1,2 @@
+export declare function requireEnv(name: string): string;
+export declare function getOptionalEnv(name: string): string | undefined;

package/dist/env.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireEnv = requireEnv;
+exports.getOptionalEnv = getOptionalEnv;
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Variável de ambiente ausente: ${name}`);
+    }
+    return value;
+}
+function getOptionalEnv(name) {
+    return process.env[name];
+}
+;

package/dist/filters/combine.d.ts

@@ -0,0 +1,10 @@
+import { Filter } from "./types";
+import { TableRow } from "../types";
+import { CombineColumnsConfig } from "./combineTypes";
+export declare class CombineFilter implements Filter<TableRow> {
+    private readonly combinations;
+    constructor(combinations: CombineColumnsConfig[]);
+    apply(rows: TableRow[]): TableRow[];
+    private rebuildRow;
+    private combine;
+}

package/dist/filters/combine.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CombineFilter = void 0;
+class CombineFilter {
+    combinations;
+    constructor(combinations) {
+        this.combinations = combinations;
+    }
+    apply(rows) {
+        const targets = new Set(this.combinations.map((c) => c.into));
+        const sourcesToRemove = new Set(this.combinations
+            .filter((c) => !c.keepSources)
+            .flatMap((c) => c.columns)
+            .filter((column) => !targets.has(column)));
+        return rows.map((row) => {
+            const combined = new Map();
+            for (const combination of this.combinations) {
+                combined.set(combination.into, this.combine(row, combination));
+            }
+            return this.rebuildRow(row, combined, sourcesToRemove);
+        });
+    }
+    rebuildRow(row, combined, sourcesToRemove) {
+        const anchorOf = new Map();
+        for (const { into, columns } of this.combinations) {
+            const anchor = columns.find((column) => column in row);
+            if (anchor !== undefined && !(into in row))
+                anchorOf.set(anchor, into);
+        }
+        const result = {};
+        for (const [column, value] of Object.entries(row)) {
+            const into = anchorOf.get(column);
+            if (into !== undefined)
+                result[into] = combined.get(into) ?? null;
+            if (combined.has(column)) {
+                result[column] = combined.get(column) ?? null;
+            }
+            else if (!sourcesToRemove.has(column)) {
+                result[column] = value;
+            }
+        }
+        for (const [into, value] of combined) {
+            if (!(into in result))
+                result[into] = value;
+        }
+        return result;
+    }
+    combine(row, { columns, separator = " " }) {
+        const values = [];
+        for (const column of columns) {
+            const raw = row[column];
+            const text = raw === null || raw === undefined ? "" : String(raw).trim();
+            if (text === "")
+                return null;
+            values.push(text);
+        }
+        return values.join(separator);
+    }
+}
+exports.CombineFilter = CombineFilter;

package/dist/filters/combineTypes.d.ts

@@ -0,0 +1,6 @@
+export interface CombineColumnsConfig {
+    into: string;
+    columns: string[];
+    separator?: string | undefined;
+    keepSources?: boolean | undefined;
+}

package/dist/filters/combineTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/filters/dedupe.d.ts

@@ -0,0 +1,12 @@
+import { Filter } from "./types";
+import { TableRow } from "../types";
+import { KeyNormalizer } from "../normalizers/registry";
+export type DedupeStrategy = "keep-first" | "keep-last";
+export declare class DedupeFilter implements Filter<TableRow> {
+    private readonly column;
+    private readonly strategy;
+    private readonly normalizer?;
+    constructor(column: string, strategy?: DedupeStrategy, normalizer?: KeyNormalizer | undefined);
+    private keyOf;
+    apply(rows: TableRow[]): TableRow[];
+}

package/dist/filters/dedupe.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DedupeFilter = void 0;
+class DedupeFilter {
+    column;
+    strategy;
+    normalizer;
+    constructor(column, strategy = "keep-first", normalizer) {
+        this.column = column;
+        this.strategy = strategy;
+        this.normalizer = normalizer;
+    }
+    keyOf(row) {
+        const raw = row[this.column];
+        if (raw === null || raw === undefined)
+            return undefined;
+        if (!this.normalizer)
+            return raw;
+        const normalized = this.normalizer(raw);
+        if (normalized === null)
+            return undefined;
+        return normalized.group === undefined
+            ? normalized.key
+            : `${normalized.group}\u0000${normalized.key}`;
+    }
+    apply(rows) {
+        const seen = new Map();
+        for (const row of rows) {
+            const key = this.keyOf(row);
+            if (key === undefined) {
+                seen.set(Symbol(), row);
+                continue;
+            }
+            if (!seen.has(key)) {
+                seen.set(key, row);
+            }
+            else if (this.strategy === "keep-last") {
+                seen.delete(key);
+                seen.set(key, row);
+            }
+        }
+        return Array.from(seen.values());
+    }
+}
+exports.DedupeFilter = DedupeFilter;

package/dist/filters/fillEmpty.d.ts

@@ -0,0 +1,9 @@
+import { Filter } from "./types";
+import { TableRow } from "../types";
+import { FillEmptyConfig } from "./fillEmptyTypes";
+export declare class FillEmptyFilter implements Filter<TableRow> {
+    private readonly rules;
+    constructor(rules: FillEmptyConfig[]);
+    apply(rows: TableRow[]): TableRow[];
+    private isEmpty;
+}

package/dist/filters/fillEmpty.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FillEmptyFilter = void 0;
+class FillEmptyFilter {
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+    }
+    apply(rows) {
+        return rows.map((row) => {
+            const result = { ...row };
+            for (const { column, fallbackColumns = [], default: fallbackValue, } of this.rules) {
+                if (!this.isEmpty(row[column]))
+                    continue;
+                const fromColumn = fallbackColumns
+                    .map((fallback) => row[fallback])
+                    .find((value) => !this.isEmpty(value));
+                if (fromColumn !== undefined) {
+                    result[column] = fromColumn;
+                }
+                else if (fallbackValue !== undefined) {
+                    result[column] = fallbackValue;
+                }
+            }
+            return result;
+        });
+    }
+    isEmpty(value) {
+        return (value === null || value === undefined || String(value).trim() === "");
+    }
+}
+exports.FillEmptyFilter = FillEmptyFilter;

package/dist/filters/fillEmptyTypes.d.ts

@@ -0,0 +1,5 @@
+export interface FillEmptyConfig {
+    column: string;
+    fallbackColumns?: string[] | undefined;
+    default?: string | undefined;
+}

package/dist/filters/fillEmptyTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/filters/merge.d.ts

@@ -0,0 +1,15 @@
+import { Filter } from "./types";
+import { TableRow } from "../types";
+import { MergeColumnConfig, MergeFilterOptions } from "./mergeTypes";
+export declare class MergeFilter implements Filter<TableRow> {
+    private readonly keyColumn;
+    private readonly columns;
+    private readonly emptyKeyLabel;
+    private readonly rejectedKeyLabel;
+    private readonly normalizeKey;
+    constructor(keyColumn: string, columns: MergeColumnConfig[], options?: MergeFilterOptions);
+    apply(rows: TableRow[]): TableRow[];
+    private hasGroupOverride;
+    private distributeOnly;
+    private mergeGroup;
+}

package/dist/filters/merge.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeFilter = void 0;
+const mergeStrategies_1 = require("./mergeStrategies");
+const mergeUnkeyed_1 = require("./mergeUnkeyed");
+const registry_1 = require("../normalizers/registry");
+const identityNormalizer = (raw) => ({
+    key: typeof raw === "string" ? raw.trim() : raw,
+});
+class MergeFilter {
+    keyColumn;
+    columns;
+    emptyKeyLabel;
+    rejectedKeyLabel;
+    normalizeKey;
+    constructor(keyColumn, columns, options = {}) {
+        this.keyColumn = keyColumn;
+        this.columns = columns;
+        this.emptyKeyLabel = options.emptyKeyLabel ?? `(sem ${keyColumn})`;
+        this.rejectedKeyLabel =
+            options.rejectedKeyLabel ?? `(${keyColumn} inválido)`;
+        const normalizer = options.keyNormalizer;
+        this.normalizeKey =
+            typeof normalizer === "string"
+                ? (0, registry_1.getKeyNormalizer)(normalizer)
+                : (normalizer ?? identityNormalizer);
+    }
+    apply(rows) {
+        const groups = new Map();
+        const emptyKeyRows = [];
+        const rejectedKeyRows = [];
+        for (const row of rows) {
+            const rawKey = row[this.keyColumn];
+            if (rawKey === null ||
+                rawKey === undefined ||
+                (typeof rawKey === "string" && rawKey.trim() === "")) {
+                emptyKeyRows.push(row);
+                continue;
+            }
+            const normalized = this.normalizeKey(rawKey);
+            if (normalized === null) {
+                rejectedKeyRows.push(row);
+                continue;
+            }
+            const groupKey = normalized.group === undefined
+                ? normalized.key
+                : `${normalized.group}\u0000${normalized.key}`;
+            const existing = groups.get(groupKey);
+            if (existing) {
+                existing.items.push(row);
+            }
+            else {
+                groups.set(groupKey, {
+                    category: normalized.group,
+                    items: [row],
+                });
+            }
+        }
+        const merged = Array.from(groups.values()).map(({ category, items }) => items.length === 1 && !this.hasGroupOverride(category)
+            ? this.distributeOnly(items[0])
+            : this.mergeGroup(items, category));
+        return [
+            ...merged,
+            ...(0, mergeUnkeyed_1.buildUnkeyedRows)(emptyKeyRows, this.emptyKeyLabel, this.keyColumn, this.columns),
+            ...(0, mergeUnkeyed_1.buildUnkeyedRows)(rejectedKeyRows, this.rejectedKeyLabel, this.keyColumn, this.columns),
+        ];
+    }
+    hasGroupOverride(category) {
+        if (category === undefined)
+            return false;
+        return this.columns.some((c) => c.byGroup?.[category] !== undefined);
+    }
+    distributeOnly(row) {
+        const distributed = this.columns.filter((c) => c.strategy === "concat" && c.distribute !== undefined);
+        if (distributed.length === 0)
+            return row;
+        const result = { ...row };
+        for (const { column, separator, distribute } of distributed) {
+            (0, mergeStrategies_1.mergeConcatDistributed)([row], column, result, distribute, separator ?? mergeStrategies_1.DEFAULT_SEPARATOR);
+        }
+        return result;
+    }
+    mergeGroup(group, category) {
+        const merged = { ...group[0] };
+        for (const { column, strategy, separator, distribute, byGroup } of this
+            .columns) {
+            const override = category === undefined ? undefined : byGroup?.[category];
+            const target = override?.into ?? column;
+            const finalSeparator = override?.separator ?? separator ?? mergeStrategies_1.DEFAULT_SEPARATOR;
+            const resolvedStrategy = override?.strategy ?? strategy;
+            const finalDistribute = override?.distribute ?? distribute;
+            if (resolvedStrategy === "concat" && finalDistribute) {
+                (0, mergeStrategies_1.mergeConcatDistributed)(group, column, merged, finalDistribute, finalSeparator);
+                continue;
+            }
+            switch (resolvedStrategy) {
+                case "overwrite":
+                    merged[target] = (0, mergeStrategies_1.mergeOverwrite)(group, column);
+                    break;
+                case "concat":
+                    merged[target] = (0, mergeStrategies_1.mergeConcat)(group, column, finalSeparator);
+                    break;
+                case "extra-column":
+                    (0, mergeStrategies_1.mergeExtraColumns)(group, column, merged, target);
+                    break;
+            }
+            if (target !== column)
+                delete merged[column];
+        }
+        return merged;
+    }
+}
+exports.MergeFilter = MergeFilter;

package/dist/filters/mergeStrategies.d.ts

@@ -0,0 +1,10 @@
+import { TableRow } from "../types";
+import { DistributeConfig } from "./mergeTypes";
+export type CellValue = string | number | null;
+export declare const DEFAULT_SEPARATOR = "; ";
+export declare function presentValues(rows: TableRow[], column: string): (string | number)[];
+export declare function mergeOverwrite(group: TableRow[], column: string): CellValue;
+export declare function mergeConcat(group: TableRow[], column: string, separator: string): string;
+export declare function mergeConcatDistributed(group: TableRow[], column: string, merged: TableRow, distribute: DistributeConfig, separator: string): void;
+export declare function findFreeOverflowColumnName(column: string, merged: TableRow): string;
+export declare function mergeExtraColumns(group: TableRow[], column: string, merged: TableRow, target?: string): void;

package/dist/filters/mergeStrategies.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SEPARATOR = void 0;
+exports.presentValues = presentValues;
+exports.mergeOverwrite = mergeOverwrite;
+exports.mergeConcat = mergeConcat;
+exports.mergeConcatDistributed = mergeConcatDistributed;
+exports.findFreeOverflowColumnName = findFreeOverflowColumnName;
+exports.mergeExtraColumns = mergeExtraColumns;
+exports.DEFAULT_SEPARATOR = "; ";
+function presentValues(rows, column) {
+    return rows
+        .map((row) => row[column])
+        .filter((v) => v !== null && v !== undefined && v !== "");
+}
+function mergeOverwrite(group, column) {
+    let result = group[0]?.[column] ?? null;
+    for (const row of group) {
+        const value = row[column];
+        if (value !== null && value !== undefined) {
+            result = value;
+        }
+    }
+    return result;
+}
+function mergeConcat(group, column, separator) {
+    const values = presentValues(group, column).map(String);
+    return Array.from(new Set(values)).join(separator);
+}
+function mergeConcatDistributed(group, column, merged, distribute, separator) {
+    const { columns, overflowInto, sources = [] } = distribute;
+    const sourceColumns = [column, ...sources];
+    const uniqueValues = Array.from(new Set(group.flatMap((row) => sourceColumns.flatMap((source) => presentValues([row], source).map(String)))));
+    for (const destination of columns) {
+        if (destination in merged)
+            merged[destination] = null;
+    }
+    uniqueValues.forEach((value, index) => {
+        if (index < columns.length) {
+            merged[columns[index]] = value;
+        }
+    });
+    const overflowValues = uniqueValues.slice(columns.length);
+    if (overflowValues.length > 0) {
+        const overflowColumn = overflowInto ?? findFreeOverflowColumnName(column, merged);
+        merged[overflowColumn] = overflowValues.join(separator);
+    }
+    for (const source of sourceColumns) {
+        if (!columns.includes(source))
+            delete merged[source];
+    }
+}
+function findFreeOverflowColumnName(column, merged) {
+    const base = `${column}_overflow`;
+    if (merged[base] === undefined)
+        return base;
+    let suffix = 2;
+    while (merged[`${base}_${suffix}`] !== undefined) {
+        suffix++;
+    }
+    return `${base}_${suffix}`;
+}
+function mergeExtraColumns(group, column, merged, target = column) {
+    const values = presentValues(group, column);
+    merged[target] = values[0] ?? null;
+    for (let i = 1; i < values.length; i++) {
+        merged[`${target}_${i + 1}`] = values[i] ?? null;
+    }
+}

package/dist/filters/mergeTypes.d.ts

@@ -0,0 +1,32 @@
+import { KeyNormalizer } from "../normalizers/registry";
+export type MergeColumnStrategy = "concat" | "overwrite" | "extra-column";
+export type UnkeyedColumnStrategy = "collapse-column";
+export interface UnkeyedColumnConfig {
+    strategy: UnkeyedColumnStrategy;
+    into?: string | undefined;
+    separator?: string | undefined;
+}
+export interface DistributeConfig {
+    columns: string[];
+    overflowInto?: string | undefined;
+    sources?: string[] | undefined;
+}
+export interface GroupColumnOverride {
+    strategy: MergeColumnStrategy;
+    separator?: string | undefined;
+    into?: string | undefined;
+    distribute?: DistributeConfig | undefined;
+}
+export interface MergeColumnConfig {
+    column: string;
+    strategy: MergeColumnStrategy;
+    separator?: string | undefined;
+    distribute?: DistributeConfig | undefined;
+    unkeyed?: UnkeyedColumnConfig | undefined;
+    byGroup?: Record<string, GroupColumnOverride> | undefined;
+}
+export interface MergeFilterOptions {
+    emptyKeyLabel?: string | undefined;
+    rejectedKeyLabel?: string | undefined;
+    keyNormalizer?: string | KeyNormalizer | undefined;
+}

package/dist/filters/mergeTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/filters/mergeUnkeyed.d.ts

@@ -0,0 +1,3 @@
+import { TableRow } from "../types";
+import { MergeColumnConfig } from "./mergeTypes";
+export declare function buildUnkeyedRows(rows: TableRow[], label: string, keyColumn: string, columns: MergeColumnConfig[]): TableRow[];

package/dist/filters/mergeUnkeyed.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUnkeyedRows = buildUnkeyedRows;
+const mergeStrategies_1 = require("./mergeStrategies");
+function buildUnkeyedRows(rows, label, keyColumn, columns) {
+    if (rows.length === 0)
+        return [];
+    const collapsing = columns.filter((c) => c.unkeyed?.strategy === "collapse-column");
+    if (collapsing.length === 0) {
+        return rows.map((row) => ({ ...row, [keyColumn]: label }));
+    }
+    const collapsed = { [keyColumn]: label };
+    for (const { column, unkeyed } of collapsing) {
+        const target = unkeyed?.into ?? `${column} ${label}`;
+        const separator = unkeyed?.separator ?? mergeStrategies_1.DEFAULT_SEPARATOR;
+        collapsed[target] = (0, mergeStrategies_1.presentValues)(rows, column)
+            .map(String)
+            .join(separator);
+    }
+    return [collapsed];
+}

package/dist/filters/types.d.ts

@@ -0,0 +1,3 @@
+export interface Filter<T> {
+    apply(rows: T[]): T[];
+}

package/dist/filters/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/filters/validate.d.ts

@@ -0,0 +1,16 @@
+import { TableRow } from "../types";
+import { ValidationRule } from "./validateTypes";
+export declare const DEFAULT_PENDING_SHEET = "Pend\u00EAncias";
+export declare const DEFAULT_REASON_COLUMN = "Motivo";
+export interface ValidationResult {
+    valid: TableRow[];
+    pending: TableRow[];
+}
+export declare class RowValidator {
+    private readonly reasonColumn;
+    private readonly checks;
+    constructor(rules: ValidationRule[], reasonColumn?: string);
+    split(rows: TableRow[]): ValidationResult;
+    private passes;
+    private buildCheck;
+}