@postxl/utils 0.1.8

package/dist/string.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upperFirst = upperFirst;
+exports.lowerFirst = lowerFirst;
+exports.pluralize = pluralize;
+exports.isPlural = isPlural;
+exports.capitalizeKeys = capitalizeKeys;
+exports.uncapitalizeKeys = uncapitalizeKeys;
+exports.uncapitalize = uncapitalize;
+exports.capitalize = capitalize;
+exports.toCamelCase = toCamelCase;
+exports.isCamelCase = isCamelCase;
+exports.toPascalCase = toPascalCase;
+exports.isPascalCase = isPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.isSnakeCase = isSnakeCase;
+exports.commentLines = commentLines;
+exports.toHumanReadable = toHumanReadable;
+exports.conjugateNames = conjugateNames;
+exports.slugify = slugify;
+exports.isSlug = isSlug;
+function upperFirst(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function lowerFirst(s) {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+}
+const IRREGULAR_PLURALS = Object.entries({
+    abyss: 'abysses',
+    aegis: 'aegises',
+    alias: 'aliases',
+    alumnus: 'alumni',
+    amends: 'amends',
+    analysis: 'analyses',
+    apparatus: 'apparatuses',
+    appendix: 'appendices',
+    asbestos: 'asbestoses',
+    atlas: 'atlases',
+    axis: 'axes',
+    basis: 'bases',
+    biceps: 'bicepses',
+    bus: 'buses',
+    caress: 'caresses',
+    child: 'children',
+    children: 'children',
+    circus: 'circuses',
+    citrus: 'citruses',
+    compass: 'compasses',
+    crisis: 'crises',
+    criterion: 'criteria',
+    crocus: 'crocuses',
+    data: 'data',
+    datum: 'data',
+    diabetes: 'diabetes',
+    diagnosis: 'diagnoses',
+    dross: 'drosses',
+    egress: 'egresses',
+    elvis: 'elvises',
+    emboss: 'embosses',
+    fiss: 'fisses',
+    focus: 'foci',
+    glass: 'glasses',
+    hippocampus: 'hippocampi',
+    // While `histories` is the plural of `history`, in a model context, `history` makes more sense:
+    // If you have a model called `UserHistory`, calling the table `UserHistories` would be confusing.
+    history: 'history',
+    hypothesis: 'hypotheses',
+    ignis: 'ignises',
+    index: 'indices',
+    iris: 'irises',
+    jesus: 'jesuses',
+    kudos: 'kudos',
+    lens: 'lenses',
+    man: 'men',
+    matrix: 'matrices',
+    medium: 'media',
+    news: 'news',
+    oasis: 'oases',
+    parenthesis: 'parentheses',
+    pass: 'passes',
+    phenomenon: 'phenomena',
+    prognosis: 'prognoses',
+    radius: 'radii',
+    ras: 'rasses',
+    sepsis: 'sepses',
+    species: 'species',
+    status: 'statuses',
+    suffix: 'suffixes',
+    syllabus: 'syllabi',
+    synopsis: 'synopses',
+    thesis: 'theses',
+    tress: 'tresses',
+    virus: 'viruses',
+    vortex: 'vortices',
+    woman: 'women',
+});
+/**
+ * Returns a pluralized version of the given string based on the count.
+ */
+function pluralize(s, count = 2) {
+    // If there's one of something we simply use the singular form.
+    if (count === 1) {
+        return s;
+    }
+    // For plural forms, we first check whether a word is irregular.
+    const lower = s.toLowerCase();
+    for (const [singular, plural] of IRREGULAR_PLURALS) {
+        // We check that items *end with* a given word because we use combined words
+        // like `UserHistory` as input values of this function.
+        if (lower.endsWith(singular)) {
+            return s.slice(0, -singular.length + 1) + plural.slice(1);
+        }
+    }
+    if (lower.endsWith('ss')) {
+        return s.slice(0, -2) + 'sses';
+    }
+    if (
+    // e.g. index
+    lower.endsWith('x') ||
+        // e.g. buzz
+        lower.endsWith('z') ||
+        // e.g. wish
+        lower.endsWith('sh') ||
+        // e.g. match
+        lower.endsWith('ch')) {
+        return s + 'es';
+    }
+    if (s.endsWith('y') &&
+        !s.endsWith('ay') &&
+        !s.endsWith('ey') &&
+        !s.endsWith('iy') &&
+        !s.endsWith('oy') &&
+        !s.endsWith('uy')) {
+        return s.slice(0, -1) + 'ies';
+    }
+    if (s.endsWith('s')) {
+        return s;
+    }
+    return s + 's';
+}
+/**
+ * Returns true if the given string is already pluralized.
+ */
+function isPlural(s) {
+    const plural = pluralize(s);
+    return plural === s;
+}
+/**
+ * Converts all keys of an object to capitalized versions in a type-safe way.
+ */
+function capitalizeKeys(obj) {
+    const result = {};
+    for (const key in obj) {
+        const cKey = `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+        const cVal = obj[key];
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        result[cKey] = cVal;
+    }
+    return result;
+}
+/**
+ * Converts all keys of an object to uncapitalized versions in a type-safe way.
+ */
+function uncapitalizeKeys(obj) {
+    const result = {};
+    for (const key in obj) {
+        const unKey = `${key.charAt(0).toLowerCase()}${key.slice(1)}`;
+        const unVal = obj[key];
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        result[unKey] = unVal;
+    }
+    return result;
+}
+/**
+ * Returns the same string with a lowercase first letter.
+ */
+function uncapitalize(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+/**
+ * Returns the same string with an uppercase first letter.
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Returns the camelCase version of the given string.
+ *
+ * Camel case examples:
+ *  `toCamelCase('hello world')` -> 'helloWorld',
+ *  `toCamelCase('hello_world')` -> 'helloWorld',
+ *  `toCamelCase('helloWorld')` -> 'helloWorld'
+ *  `toCamelCase('HelloWorld')` -> 'helloWorld'
+ *  `toCamelCase('hello_world')` -> 'helloWorld'
+ */
+function toCamelCase(str) {
+    if (/^[a-z]+(?:[A-Z][a-z]*)*$/.test(str)) {
+        return str;
+    }
+    // Split the string into an array of words
+    // We split on spaces, underscores, and hyphens.
+    // We also split on single uppercase letters, though not on consecutive uppercase letters.
+    const words = str.split(/(?<![A-Z])(?=[A-Z])|[\s_-]+/);
+    // Convert the first word to lowercase and capitalize the rest
+    const camelCasedWords = words
+        .map((word) => (word.toUpperCase() === word ? word.toLowerCase() : word))
+        .map((word, index) => (index === 0 ? lowerFirst(word) : upperFirst(word)));
+    // Join the words back together into a single string
+    const camelCasedStr = camelCasedWords.join('');
+    return camelCasedStr;
+}
+/**
+ * Validates if a string is in camelCase format
+ */
+function isCamelCase(str) {
+    return str === toCamelCase(str);
+}
+/**
+ * Returns the PascalCase version of the given string.
+ *
+ * Examples:
+ *   `toPascalCase('hello world')` -> 'HelloWorld'
+ *   `toPascalCase('hello_world')` -> 'HelloWorld'
+ *   `toPascalCase('helloWorld')` -> 'HelloWorld'
+ *   `toPascalCase('Hello-World')` -> 'HelloWorld'
+ *   `toPascalCase('HELLO_WORLD')` -> 'HelloWorld'
+ */
+function toPascalCase(str) {
+    const s = toCamelCase(str);
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/**
+ * Validates if a string is in PascalCase format
+ */
+function isPascalCase(str) {
+    return str === toPascalCase(str);
+}
+/**
+ * Returns the snake_case version of the given string.
+ *
+ * Examples:
+ *   `toSnakeCase('hello world')` -> 'hello_world'
+ *   `toSnakeCase('helloWorld')` -> 'hello_world'
+ *   `toSnakeCase('HelloWorld')` -> 'hello_world'
+ *   `toSnakeCase('HELLO_WORLD')` -> 'hello_world'
+ */
+function toSnakeCase(str) {
+    const camelCase = toCamelCase(str);
+    return camelCase.replace(/([A-Z])/g, '_$1').toLowerCase();
+}
+/**
+ * Validates if a string is in snake_case format
+ */
+function isSnakeCase(str) {
+    return str === toSnakeCase(str);
+}
+/**
+ * Converts each line of a string to a commented line
+ */
+function commentLines(lines) {
+    return lines
+        .split('\n')
+        .map((l) => `// ${l}`)
+        .join('\n');
+}
+function toHumanReadable(input) {
+    // Replace underscores and hyphens with spaces
+    let result = input.replace(/[_-]/g, ' ');
+    // Add spaces before capital letters
+    result = result.replace(/([a-z])([A-Z])/g, '$1 $2');
+    //In case the string was already human readable, return it
+    if (result === input) {
+        return input;
+    }
+    //lowercase the first letter of every word
+    result = result
+        .split(' ')
+        .map((s) => s.toLowerCase())
+        .join(' ');
+    // Capitalize the first letter of the resulting string
+    result = upperFirst(result);
+    return result;
+}
+/**
+ * Provide all relevant conjugation of a name
+ */
+function conjugateNames(name) {
+    return {
+        PascalCase: toPascalCase(name),
+        PascalCasePlural: toPascalCase(pluralize(name)),
+        camelCase: toCamelCase(name),
+        camelCasePlural: toCamelCase(pluralize(name)),
+        snake_case: toSnakeCase(name),
+        snake_case_plural: toSnakeCase(pluralize(name)),
+        pluralized: capitalize(pluralize(name)),
+        uncapitalizedPlural: uncapitalize(pluralize(name)),
+        uncapitalized: uncapitalize(name),
+        capitalized: capitalize(name),
+        capitalizedPlural: capitalize(pluralize(name)),
+    };
+}
+function slugify(str) {
+    return (str
+        // replace uppercase letters with hyphens and letter (will be lowercased later)
+        .replace(/([A-Z])/g, '-$1')
+        .toLowerCase()
+        // replace letter followed by number with letter-number
+        .replace(/([a-z])(\d)/g, '$1-$2')
+        // replace non-alphanumeric characters with hyphens
+        .replace(/[^a-z0-9]+/g, '-')
+        // remove leading hyphens
+        .replace(/^-/g, '')
+        // remove trailing hyphens
+        .replace(/-$/g, '')
+        // replace multiple hyphens with a single hyphen
+        .replace(/-+/g, '-'));
+}
+function isSlug(str) {
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+export type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+export type Exact<T, I> = T extends I ? (Exclude<keyof T, keyof I> extends never ? T : never) : never;
+export type UncapitalizeObjectKeys<T> = {
+    [key in keyof T as Uncapitalize<key & string>]: T[key];
+};
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * Distributive Pick - does not collapse unions into a "shared type" only to
+ * run Pick on it. Instead, it "picks" from each union item separately.
+ *
+ * See https://github.com/klimashkin/css-modules-theme/pull/8
+ *
+ * Example:
+ *      Pick<{ type: "pick" } | { type: "omit" }, "type">
+ *  produces { type: "pick" | "omit" }
+ *
+ * UnionPick<{ type: "pick" } | { type: "omit" }, "type">
+ *  produces { type: "pick" } | { type: "omit" }
+ */
+export type UnionPick<T, K extends keyof T> = T extends unknown ? Pick<T, K> : never;
+/**
+ * Like UnionPick, but for Omit
+ */
+export type UnionOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Makes a type check that is only valid when all cases of a switch
+ * statement have been covered.
+ */
+export declare class ExhaustiveSwitchCheck extends Error {
+    constructor(val: never);
+}
+/**
+ * A type that represents an array that is guaranteed to have at least one element.
+ */
+export type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Converts a nested object to a nested object where all properties are optional.
+ */
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/**
+ * Changes properties of an object type to optional.
+ *
+ * Example:
+ *      type Foo = { a: string, b: number, c: boolean }
+ *      type Bar = Optional<Foo, 'a' | 'b'>
+ *      // Bar is { a?: string, b?: number, c: boolean }
+ */
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Applies a type assertion to an entire array and hence asserts the array.
+ *
+ * Type assertions are especially useful when you want to modify and object in place - a function
+ * with a type assertion lets TypeScript know that the object was modified.
+ *
+ * Example:
+ * ```
+ * type Original = { a: number }
+ * type WithExtra = Original & { b: string }
+ *
+ * function addExtra(obj: Original): asserts obj is WithExtra {
+ *   obj.b = 'new value'
+ * }
+ *
+ * const myObj: Original[] = [{ a: 1 }]
+ * console.log(myObj[0].b) // ❌ TypeScript error!
+ * assertArray(myObj, addExtra)
+ * console.log(myObj[0].b) // ✅ No TypeScript error!
+ * ```
+ */
+export declare function assertArray<I, O extends I>(obj: I[], fn: (i: I) => asserts i is O): asserts obj is O[];
+export {};

package/dist/types.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExhaustiveSwitchCheck = void 0;
+exports.assertArray = assertArray;
+/**
+ * Makes a type check that is only valid when all cases of a switch
+ * statement have been covered.
+ */
+class ExhaustiveSwitchCheck extends Error {
+    constructor(val) {
+        super(`Unreachable case: ${JSON.stringify(val)}`);
+    }
+}
+exports.ExhaustiveSwitchCheck = ExhaustiveSwitchCheck;
+/**
+ * Applies a type assertion to an entire array and hence asserts the array.
+ *
+ * Type assertions are especially useful when you want to modify and object in place - a function
+ * with a type assertion lets TypeScript know that the object was modified.
+ *
+ * Example:
+ * ```
+ * type Original = { a: number }
+ * type WithExtra = Original & { b: string }
+ *
+ * function addExtra(obj: Original): asserts obj is WithExtra {
+ *   obj.b = 'new value'
+ * }
+ *
+ * const myObj: Original[] = [{ a: 1 }]
+ * console.log(myObj[0].b) // ❌ TypeScript error!
+ * assertArray(myObj, addExtra)
+ * console.log(myObj[0].b) // ✅ No TypeScript error!
+ * ```
+ */
+function assertArray(obj, fn) {
+    obj.forEach(fn);
+}

package/dist/uniq.d.ts

@@ -0,0 +1 @@
+export declare function uniq<T>(items: T[], predicate: (item: T) => number): T[];

package/dist/uniq.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniq = uniq;
+function uniq(items, predicate) {
+    const result = [];
+    const seen = {};
+    for (const item of items) {
+        const key = predicate(item);
+        if (!seen[key]) {
+            seen[key] = true;
+            result.push(item);
+        }
+    }
+    return result;
+}

package/dist/zod-excel.decoders.d.ts

@@ -0,0 +1,151 @@
+import z from 'zod';
+/**
+ * A decoder that transforms Excel strings to JS strings, also handling numbers and boolean. Will not parse any other type!
+ *
+ * Background: In Excel, entering a number in a cell will automatically convert it to a number -
+ * and xlPort will return it as a number. However, often we want to treat it as a string - this decoder
+ * hence accepts both strings and numbers, and converts numbers to strings.
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll be converted to a string
+ * - If the value is a string, it'll be returned as-is
+ * - If the value is boolean, it'll return 'true' or 'false'
+ *
+ * Any other type will throw an error!
+ */
+export declare const excelStringStrictDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, string, string | number | boolean>;
+/**
+ * A decoder that transforms Excel strings to JS strings, also handling numbers and any other potential type
+ *
+ * Background: In Excel, entering a number in a cell will automatically convert it to a number -
+ * and xlPort will return it as a number. However, often we want to treat it as a string - this decoder
+ * hence accepts both strings and numbers, and converts numbers to strings.
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll be converted to a string
+ * - If the value is a string, it'll be returned as-is
+ * - If the value is boolean, it'll return 'true' or 'false'
+ * - If the value is null or undefined, it'll return an empty string
+ * - If the value is any other type, it'll return an empty string
+ */
+export declare const excelStringDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined, z.ZodAny]>, string, any>;
+/**
+ * A decoder that transforms Excel strings to JS strings, also handling numbers and null
+ *
+ * Background: In Excel, entering a number in a cell will automatically convert it to a number -
+ * and xlPort will return it as a number. However, often we want to treat it as a string - this decoder
+ * hence accepts both strings and numbers, and converts numbers to strings.
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll be converted to a string
+ * - If the value is a string, it'll be returned as-is
+ * - If the value is boolean, it'll return 'true' or 'false'
+ * - If the value is null or undefined, it'll return null
+ * - If the value is any other type, it'll return null
+ */
+export declare const excelStringNullableDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined, z.ZodAny]>, string | null, any>;
+/**
+ * A decoder that transforms Excel numbers to JS numbers, also handling strings and boolean. Will not parse any other type!
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll be returned as-is
+ * - If the value is a string, it'll try to parse it to a number. Blank strings will be converted to 0. Non-numeric strings will throw an error.
+ * - If the value is boolean, it'll return 1 or 0
+ * - If the value is any other type, it'll throw an error
+ *
+ */
+export declare const excelNumberStrictDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, number, string | number | boolean>;
+/**
+ * A decoder that transforms Excel numbers to JS numbers, also handling strings, boolean and other types.
+ 
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll be returned as-is
+ * - If the value is a string, it'll try to parse it to a number. Blank strings and non-numerical strings will be converted to 0.
+ * - If the value is boolean, it'll return 1 or 0
+ * - If the value is any other type, it'll return 0
+ */
+export declare const excelNumberDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined, z.ZodAny]>, number, any>;
+/**
+ * A decoder that transforms Excel numbers to JS numbers, also handling strings, boolean and other types.
+ 
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll be returned as-is
+ * - If the value is a string, it'll try to parse it to a number. Blank strings and non-numerical strings will be converted to 0.
+ * - If the value is boolean, it'll return 1 or 0
+ * - If the value is any other type, it'll return null
+ */
+export declare const excelNumberNullableDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNull, z.ZodNumber, z.ZodUndefined, z.ZodAny]>, number | null, any>;
+/**
+ * A decoder that transforms Excel numbers to JS integers, also handling strings and boolean. Other types will throw an error.
+ *
+ * If the number is not an integer, an error will be thrown.
+ */
+export declare const excelIntStrictDecoder: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, number, string | number | boolean>, number, string | number | boolean>;
+/**
+ * A decoder that transforms Excel numbers to JS integers, also handling strings and boolean. Other types will be converted to 0.
+ *
+ * If the number is not an integer, an error will be thrown.
+ */
+export declare const excelIntDecoder: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined, z.ZodAny]>, number, any>, number, any>;
+/**
+ * A decoder that transforms Excel numbers to JS integers, also handling strings and boolean. Other types will be converted to null.
+ *
+ * If the number is not an integer, an error will be thrown.
+ */
+export declare const excelIntNullableDecoder: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNull, z.ZodNumber, z.ZodUndefined, z.ZodAny]>, number | null, any>, number | null, any>;
+/**
+ * A decoder that transforms Excel numbers to JS BigInts, also handling strings and boolean. Other types will throw an error.
+ *
+ * If the number is not a (big) integer, an error will be thrown.
+ */
+export declare const excelBigIntStrictDecoder: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, number, string | number | boolean>, bigint, string | number | boolean>;
+/**
+ * A decoder that transforms Excel numbers to JS BigInts, also handling strings and boolean. Other types will be converted to 0.
+ *
+ * If the number is not a (big) integer, an error will be thrown.
+ */
+export declare const excelBigIntDecoder: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined, z.ZodAny]>, number, any>, bigint, any>;
+/**
+ * A decoder that transforms Excel numbers to JS BigInts, also handling strings and boolean. Other types will be converted to null.
+ *
+ * If the number is not a (big) integer, an error will be thrown.
+ */
+export declare const excelBigIntNullableDecoder: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNull, z.ZodNumber, z.ZodUndefined, z.ZodAny]>, number | null, any>, bigint | null, any>;
+/**
+ * A decoder that transforms Excel booleans to JS booleans, also handling numbers and strings.
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll return true if it's not 0
+ * - If the value is a string, it'll return true if it's 'true' or '1', false if it's 'false' or '0', and throw an error otherwise
+ * - If the value is boolean, it'll return it as-is
+ * - If the value is any other type, it'll throw an error
+ */
+export declare const excelBooleanStrictDecoder: z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodString]>, boolean, string | number | boolean>;
+/**
+ * A decoder that transforms Excel booleans to JS booleans, also handling numbers and strings.
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll return true if it's not 0
+ * - If the value is a string, it'll return true if it's 'true' or '1', false otherwise
+ * - If the value is boolean, it'll return it as-is
+ * - If the value is any other type, it'll return false
+ */
+export declare const excelBooleanDecoder: z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodNull, z.ZodString, z.ZodUndefined, z.ZodAny]>, boolean, any>;
+/**
+ * A decoder that transforms Excel booleans to JS booleans, also handling numbers and strings.
+ *
+ * It'll perform casting based on the following rules:
+ * - If the value is a number, it'll return true if it's not 0
+ * - If the value is a string, it'll return true if it's 'true' or '1', false if it's 'false' or '0', and null otherwise
+ * - If the value is boolean, it'll return it as-is
+ * - If the value is any other type, it'll return null
+ */
+export declare const excelBooleanNullableDecoder: z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodNull, z.ZodString, z.ZodUndefined, z.ZodAny]>, boolean | null, any>;
+/**
+ * A decoder that transforms Excel dates to JS Dates
+ */
+export declare const excelDateDecoder: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString]>, Date, string | number>;
+/**
+ * A decoder that transforms nullable Excel dates to JS Dates
+ */
+export declare const excelDateNullableDecoder: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull, z.ZodUndefined, z.ZodAny]>, Date | null, any>;