datera 0.1.0

package/dist/config/index.d.ts

@@ -0,0 +1,7 @@
+export { etlConfigSchema } from "./schema";
+export type { EtlConfig } from "./schema";
+export type { SourceConfig, DestinationConfig } from "./ioSchema";
+export { loadConfig, loadJsonConfig, parseConfig, withEnv } from "./load";
+export { checkConfigFile, checkConfigText, formatCheck } from "./check";
+export type { ConfigCheck, ConfigProblem } from "./check";
+export { translateIssue } from "./messages";

package/dist/config/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateIssue = exports.formatCheck = exports.checkConfigText = exports.checkConfigFile = exports.withEnv = exports.parseConfig = exports.loadJsonConfig = exports.loadConfig = exports.etlConfigSchema = void 0;
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "etlConfigSchema", { enumerable: true, get: function () { return schema_1.etlConfigSchema; } });
+var load_1 = require("./load");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_1.loadConfig; } });
+Object.defineProperty(exports, "loadJsonConfig", { enumerable: true, get: function () { return load_1.loadJsonConfig; } });
+Object.defineProperty(exports, "parseConfig", { enumerable: true, get: function () { return load_1.parseConfig; } });
+Object.defineProperty(exports, "withEnv", { enumerable: true, get: function () { return load_1.withEnv; } });
+var check_1 = require("./check");
+Object.defineProperty(exports, "checkConfigFile", { enumerable: true, get: function () { return check_1.checkConfigFile; } });
+Object.defineProperty(exports, "checkConfigText", { enumerable: true, get: function () { return check_1.checkConfigText; } });
+Object.defineProperty(exports, "formatCheck", { enumerable: true, get: function () { return check_1.formatCheck; } });
+var messages_1 = require("./messages");
+Object.defineProperty(exports, "translateIssue", { enumerable: true, get: function () { return messages_1.translateIssue; } });

package/dist/config/ioSchema.d.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"mysql">;
+}, z.core.$strip>, z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"postgres">;
+    ssl: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"sqlserver">;
+    encrypt: z.ZodOptional<z.ZodBoolean>;
+    trustServerCertificate: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodString;
+    table: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"csv">;
+    path: z.ZodString;
+    delimiter: z.ZodOptional<z.ZodString>;
+    encoding: z.ZodOptional<z.ZodEnum<{
+        latin1: "latin1";
+        "utf-8": "utf-8";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"json">;
+    path: z.ZodString;
+    recordsPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"xml">;
+    path: z.ZodString;
+    recordsPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"parquet">;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"excel">;
+    path: z.ZodString;
+    sheet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sheets">;
+    spreadsheetId: z.ZodString;
+    credentialsPath: z.ZodOptional<z.ZodString>;
+    sheet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    adapter: z.ZodString;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>], "type">;
+export declare const destinationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"sheets">;
+    spreadsheetId: z.ZodOptional<z.ZodString>;
+    credentialsPath: z.ZodOptional<z.ZodString>;
+    sheet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"csv">;
+    path: z.ZodString;
+    delimiter: z.ZodOptional<z.ZodString>;
+    bom: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"json">;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"xml">;
+    path: z.ZodString;
+    root: z.ZodOptional<z.ZodString>;
+    record: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"parquet">;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"excel">;
+    path: z.ZodString;
+    sheet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    adapter: z.ZodString;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>], "type">;
+export type SourceConfig = z.infer<typeof sourceSchema>;
+export type DestinationConfig = z.infer<typeof destinationSchema>;

package/dist/config/ioSchema.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destinationSchema = exports.sourceSchema = void 0;
+const zod_1 = require("zod");
+const xmlName = zod_1.z
+    .string()
+    .regex(/^[\p{L}_][\p{L}\p{N}_.-]*$/u, "Nome de elemento XML inválido: use letras, números, _ . ou -, começando com letra.");
+const serverFields = {
+    host: zod_1.z.string().optional(),
+    port: zod_1.z.number().optional(),
+    user: zod_1.z.string().optional(),
+    password: zod_1.z.string().optional(),
+    database: zod_1.z.string().optional(),
+    table: zod_1.z.string().optional(),
+};
+exports.sourceSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("mysql"),
+        ...serverFields,
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("postgres"),
+        ...serverFields,
+        ssl: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("sqlserver"),
+        ...serverFields,
+        encrypt: zod_1.z.boolean().optional(),
+        trustServerCertificate: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("sqlite"),
+        path: zod_1.z.string(),
+        table: zod_1.z.string().min(1),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("csv"),
+        path: zod_1.z.string(),
+        delimiter: zod_1.z.string().min(1).optional(),
+        encoding: zod_1.z.enum(["utf-8", "latin1"]).optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("json"),
+        path: zod_1.z.string(),
+        recordsPath: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("xml"),
+        path: zod_1.z.string(),
+        recordsPath: zod_1.z.string().min(1).optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("parquet"),
+        path: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("excel"),
+        path: zod_1.z.string(),
+        sheet: zod_1.z.string().min(1).optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("sheets"),
+        spreadsheetId: zod_1.z.string().min(1),
+        credentialsPath: zod_1.z.string().optional(),
+        sheet: zod_1.z.string().min(1).optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("custom"),
+        adapter: zod_1.z.string().min(1),
+        options: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    }),
+]);
+exports.destinationSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("sheets"),
+        spreadsheetId: zod_1.z.string().optional(),
+        credentialsPath: zod_1.z.string().optional(),
+        sheet: zod_1.z.string().min(1).optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("csv"),
+        path: zod_1.z.string(),
+        delimiter: zod_1.z.string().min(1).optional(),
+        bom: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("json"),
+        path: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("xml"),
+        path: zod_1.z.string(),
+        root: xmlName.optional(),
+        record: xmlName.optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("parquet"),
+        path: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("excel"),
+        path: zod_1.z.string(),
+        sheet: zod_1.z.string().min(1).optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("custom"),
+        adapter: zod_1.z.string().min(1),
+        options: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    }),
+]);

package/dist/config/load.d.ts

@@ -0,0 +1,5 @@
+import { EtlConfig } from "./schema";
+export declare function loadJsonConfig(filePath: string): EtlConfig;
+export declare function withEnv(jsonConfig: EtlConfig): EtlConfig;
+export declare function loadConfig(jsonPath: string): EtlConfig;
+export declare function parseConfig(value: unknown): EtlConfig;

package/dist/config/load.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJsonConfig = loadJsonConfig;
+exports.withEnv = withEnv;
+exports.loadConfig = loadConfig;
+exports.parseConfig = parseConfig;
+const fs_1 = __importDefault(require("fs"));
+const env_1 = require("../env");
+const schema_1 = require("./schema");
+function loadJsonConfig(filePath) {
+    const content = fs_1.default.readFileSync(filePath, "utf-8");
+    const parsedData = JSON.parse(content);
+    return schema_1.etlConfigSchema.parse(parsedData);
+}
+function withDatabaseEnv(source) {
+    if (source?.type !== "mysql" &&
+        source?.type !== "postgres" &&
+        source?.type !== "sqlserver")
+        return source;
+    const port = (0, env_1.getOptionalEnv)("DB_PORT");
+    return {
+        ...source,
+        host: (0, env_1.getOptionalEnv)("DB_HOST") ?? source.host,
+        port: port !== undefined ? Number(port) : source.port,
+        user: (0, env_1.getOptionalEnv)("DB_USER") ?? source.user,
+        password: (0, env_1.getOptionalEnv)("DB_PASSWORD") ?? source.password,
+        database: (0, env_1.getOptionalEnv)("DB_NAME") ?? source.database,
+        table: (0, env_1.getOptionalEnv)("DB_TABLE") ?? source.table,
+    };
+}
+function withSheetsEnv(destination) {
+    if (destination?.type !== "sheets")
+        return destination;
+    return {
+        ...destination,
+        spreadsheetId: (0, env_1.getOptionalEnv)("GOOGLE_SPREADSHEET_ID") ??
+            destination.spreadsheetId,
+        credentialsPath: (0, env_1.getOptionalEnv)("GOOGLE_SERVICE_ACCOUNT_KEY_PATH") ??
+            destination.credentialsPath,
+    };
+}
+function withEnv(jsonConfig) {
+    const dbPort = (0, env_1.getOptionalEnv)("DB_PORT");
+    const finalConfig = {
+        ...jsonConfig,
+        source: withDatabaseEnv(jsonConfig.source),
+        destination: withSheetsEnv(jsonConfig.destination),
+        tableName: (0, env_1.getOptionalEnv)("DB_TABLE") ?? jsonConfig.tableName,
+        spreadsheetId: (0, env_1.getOptionalEnv)("GOOGLE_SPREADSHEET_ID") ?? jsonConfig.spreadsheetId,
+        credentialsPath: (0, env_1.getOptionalEnv)("GOOGLE_SERVICE_ACCOUNT_KEY_PATH") ??
+            jsonConfig.credentialsPath,
+        dbHost: (0, env_1.getOptionalEnv)("DB_HOST") ?? jsonConfig.dbHost,
+        dbPort: dbPort !== undefined ? Number(dbPort) : jsonConfig.dbPort,
+        dbUser: (0, env_1.getOptionalEnv)("DB_USER") ?? jsonConfig.dbUser,
+        dbPassword: (0, env_1.getOptionalEnv)("DB_PASSWORD") ?? jsonConfig.dbPassword,
+        dbName: (0, env_1.getOptionalEnv)("DB_NAME") ?? jsonConfig.dbName,
+    };
+    return schema_1.etlConfigSchema.parse(finalConfig);
+}
+function loadConfig(jsonPath) {
+    return withEnv(loadJsonConfig(jsonPath));
+}
+function parseConfig(value) {
+    return withEnv(schema_1.etlConfigSchema.parse(value));
+}

package/dist/config/mergeSchema.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const mergeColumnSchema: z.ZodObject<{
+    column: z.ZodString;
+    strategy: z.ZodEnum<{
+        concat: "concat";
+        "extra-column": "extra-column";
+        overwrite: "overwrite";
+    }>;
+    separator: z.ZodOptional<z.ZodString>;
+    distribute: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodArray<z.ZodString>;
+        overflowInto: z.ZodOptional<z.ZodString>;
+        sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    byGroup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        strategy: z.ZodEnum<{
+            concat: "concat";
+            "extra-column": "extra-column";
+            overwrite: "overwrite";
+        }>;
+        separator: z.ZodOptional<z.ZodString>;
+        into: z.ZodOptional<z.ZodString>;
+        distribute: z.ZodOptional<z.ZodObject<{
+            columns: z.ZodArray<z.ZodString>;
+            overflowInto: z.ZodOptional<z.ZodString>;
+            sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    unkeyed: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodEnum<{
+            "collapse-column": "collapse-column";
+        }>;
+        into: z.ZodOptional<z.ZodString>;
+        separator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/config/mergeSchema.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeColumnSchema = void 0;
+const zod_1 = require("zod");
+const mergeColumnStrategySchema = zod_1.z.enum([
+    "concat",
+    "overwrite",
+    "extra-column",
+]);
+const distributeSchema = zod_1.z.object({
+    columns: zod_1.z.array(zod_1.z.string()).min(1),
+    overflowInto: zod_1.z.string().optional(),
+    sources: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const distributeOnlyOnConcat = {
+    message: 'distribute só é permitido quando strategy é "concat".',
+    path: ["distribute"],
+};
+const groupOverrideSchema = zod_1.z
+    .object({
+    strategy: mergeColumnStrategySchema,
+    separator: zod_1.z.string().optional(),
+    into: zod_1.z.string().optional(),
+    distribute: distributeSchema.optional(),
+})
+    .refine((value) => value.strategy === "concat" || value.distribute === undefined, distributeOnlyOnConcat)
+    .refine((value) => value.into === undefined || value.distribute === undefined, {
+    message: "into e distribute não podem ser usados juntos, o distribute já define as colunas de destino.",
+    path: ["into"],
+});
+exports.mergeColumnSchema = zod_1.z
+    .object({
+    column: zod_1.z.string(),
+    strategy: mergeColumnStrategySchema,
+    separator: zod_1.z.string().optional(),
+    distribute: distributeSchema.optional(),
+    byGroup: zod_1.z.record(zod_1.z.string(), groupOverrideSchema).optional(),
+    unkeyed: zod_1.z
+        .object({
+        strategy: zod_1.z.enum(["collapse-column"]),
+        into: zod_1.z.string().optional(),
+        separator: zod_1.z.string().optional(),
+    })
+        .optional(),
+})
+    .refine((value) => value.strategy === "concat" || value.distribute === undefined, distributeOnlyOnConcat);

package/dist/config/messages.d.ts

@@ -0,0 +1,7 @@
+export interface IssueLike {
+    code: string;
+    message: string;
+    expected?: unknown;
+    values?: unknown;
+}
+export declare function translateIssue(issue: IssueLike): string;

package/dist/config/messages.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateIssue = translateIssue;
+const TYPE_NAMES = {
+    string: "texto",
+    number: "número",
+    boolean: "true ou false",
+    array: "lista",
+    object: "objeto",
+};
+function translateIssue(issue) {
+    const expected = typeof issue.expected === "string"
+        ? (TYPE_NAMES[issue.expected] ?? issue.expected)
+        : "";
+    switch (issue.code) {
+        case "invalid_type":
+            return /received undefined/.test(issue.message)
+                ? `Campo obrigatório (${expected}).`
+                : `Tipo errado: aqui vai ${expected}.`;
+        case "invalid_value":
+            return Array.isArray(issue.values)
+                ? `Valor não aceito. Use um destes: ${issue.values.map((value) => JSON.stringify(value)).join(", ")}.`
+                : "Valor não aceito.";
+        case "invalid_union":
+            return "Valor não aceito aqui. Confira o type e os campos obrigatórios.";
+        case "too_small":
+            return "Não pode ficar vazio.";
+        case "unrecognized_keys":
+            return "Tem campos que o Datera não conhece.";
+        default:
+            return issue.message;
+    }
+}

package/dist/config/prepareSchema.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const fillEmptySchema: z.ZodObject<{
+    column: z.ZodString;
+    fallbackColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const combineColumnsSchema: z.ZodObject<{
+    into: z.ZodString;
+    columns: z.ZodArray<z.ZodString>;
+    separator: z.ZodOptional<z.ZodString>;
+    keepSources: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/config/prepareSchema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineColumnsSchema = exports.fillEmptySchema = void 0;
+const zod_1 = require("zod");
+exports.fillEmptySchema = zod_1.z.object({
+    column: zod_1.z.string(),
+    fallbackColumns: zod_1.z.array(zod_1.z.string()).optional(),
+    default: zod_1.z.string().optional(),
+});
+exports.combineColumnsSchema = zod_1.z.object({
+    into: zod_1.z.string(),
+    columns: zod_1.z.array(zod_1.z.string()).min(1),
+    separator: zod_1.z.string().optional(),
+    keepSources: zod_1.z.boolean().optional(),
+});

package/dist/config/schema.d.ts

@@ -0,0 +1,195 @@
+import { z } from "zod";
+export declare const etlConfigSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"mysql">;
+    }, z.core.$strip>, z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"postgres">;
+        ssl: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"sqlserver">;
+        encrypt: z.ZodOptional<z.ZodBoolean>;
+        trustServerCertificate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sqlite">;
+        path: z.ZodString;
+        table: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"csv">;
+        path: z.ZodString;
+        delimiter: z.ZodOptional<z.ZodString>;
+        encoding: z.ZodOptional<z.ZodEnum<{
+            latin1: "latin1";
+            "utf-8": "utf-8";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        path: z.ZodString;
+        recordsPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"xml">;
+        path: z.ZodString;
+        recordsPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"parquet">;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"excel">;
+        path: z.ZodString;
+        sheet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sheets">;
+        spreadsheetId: z.ZodString;
+        credentialsPath: z.ZodOptional<z.ZodString>;
+        sheet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        adapter: z.ZodString;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>], "type">>;
+    destination: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"sheets">;
+        spreadsheetId: z.ZodOptional<z.ZodString>;
+        credentialsPath: z.ZodOptional<z.ZodString>;
+        sheet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"csv">;
+        path: z.ZodString;
+        delimiter: z.ZodOptional<z.ZodString>;
+        bom: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"xml">;
+        path: z.ZodString;
+        root: z.ZodOptional<z.ZodString>;
+        record: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"parquet">;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"excel">;
+        path: z.ZodString;
+        sheet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        adapter: z.ZodString;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>], "type">>;
+    tableName: z.ZodOptional<z.ZodString>;
+    spreadsheetId: z.ZodOptional<z.ZodString>;
+    credentialsPath: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        dedupe: "dedupe";
+        merge: "merge";
+        raw: "raw";
+    }>;
+    dbHost: z.ZodOptional<z.ZodString>;
+    dbPort: z.ZodOptional<z.ZodNumber>;
+    dbUser: z.ZodOptional<z.ZodString>;
+    dbPassword: z.ZodOptional<z.ZodString>;
+    dbName: z.ZodOptional<z.ZodString>;
+    dedupeColumn: z.ZodOptional<z.ZodString>;
+    dedupeStrategy: z.ZodOptional<z.ZodEnum<{
+        "keep-first": "keep-first";
+        "keep-last": "keep-last";
+    }>>;
+    dedupeKeyNormalizer: z.ZodOptional<z.ZodString>;
+    mergeKeyColumn: z.ZodOptional<z.ZodString>;
+    mergeColumns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        strategy: z.ZodEnum<{
+            concat: "concat";
+            "extra-column": "extra-column";
+            overwrite: "overwrite";
+        }>;
+        separator: z.ZodOptional<z.ZodString>;
+        distribute: z.ZodOptional<z.ZodObject<{
+            columns: z.ZodArray<z.ZodString>;
+            overflowInto: z.ZodOptional<z.ZodString>;
+            sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        byGroup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            strategy: z.ZodEnum<{
+                concat: "concat";
+                "extra-column": "extra-column";
+                overwrite: "overwrite";
+            }>;
+            separator: z.ZodOptional<z.ZodString>;
+            into: z.ZodOptional<z.ZodString>;
+            distribute: z.ZodOptional<z.ZodObject<{
+                columns: z.ZodArray<z.ZodString>;
+                overflowInto: z.ZodOptional<z.ZodString>;
+                sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        unkeyed: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<{
+                "collapse-column": "collapse-column";
+            }>;
+            into: z.ZodOptional<z.ZodString>;
+            separator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    mergeEmptyKeyLabel: z.ZodOptional<z.ZodString>;
+    mergeRejectedKeyLabel: z.ZodOptional<z.ZodString>;
+    mergeKeyNormalizer: z.ZodOptional<z.ZodString>;
+    normalizerModules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    adapterModules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fillEmpty: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        fallbackColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    combineColumns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        into: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        separator: z.ZodOptional<z.ZodString>;
+        keepSources: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    validation: z.ZodOptional<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>>;
+}, z.core.$strip>;
+export type EtlConfig = z.infer<typeof etlConfigSchema>;