@postxl/utils 1.0.1 → 1.2.0

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

@@ -0,0 +1,775 @@
+import z$1, { z } from "zod";
+
+//#region src/DefaultMap.d.ts
+/**
+* A map extension that returns a default value if the key is not found.
+*/
+/**
+ * A map extension that returns a default value if the key is not found.
+ */
+declare class DefaultMap<Key, Value> extends Map<Key, Value> {
+  private readonly _default;
+  /**
+   * A function that returns the default value for the map.
+   */
+  constructor(_default: () => Value);
+  get(key: Key): Value;
+}
+
+//#endregion
+//#region src/NestedMap.d.ts
+declare class NestedMap<Key1, Key2, Item> {
+  private readonly getKey1;
+  private readonly getKey2;
+  private readonly _map;
+  constructor(getKey1: (item: Item) => Key1, getKey2: (item: Item) => Key2, items?: Item[]);
+  get(key1: Key1, key2: Key2): Item | undefined;
+  private getKeys;
+  set(item: Item): void;
+  delete(item: Item): void;
+  clear(): void;
+  get size(): number;
+  get keys(): Iterable<Key1>;
+  get values(): Iterable<Item>;
+  get entries(): Iterable<[Key1, Key2, Item]>;
+  get [Symbol.iterator](): Iterable<[Key1, Key2, Item]>;
+}
+
+//#endregion
+//#region src/TypedMapping.d.ts
+type IdentifiersBase = Record<string, string>;
+type Mapping<T> = Map<T, T>;
+/**
+ * A map of typed mappings.
+ */
+declare class TypedMapping<Identifiers extends IdentifiersBase> {
+  private mappings;
+  constructor(mappings?: { [Model in keyof Identifiers]?: Mapping<Identifiers[Model]> });
+  /**
+   * Creates a new mapping from the original id to the new id.
+   */
+  set<Model extends keyof Identifiers>({
+    model,
+    id
+  }: {
+    model: Model;
+    id: Identifiers[Model];
+  }, newId: Identifiers[Model]): this;
+  /**
+   * Returns the id if there exists a mapping, otherwise returns the original id.
+   */
+  get<Model extends keyof Identifiers>({
+    model,
+    id
+  }: {
+    model: Model;
+    id: Identifiers[Model];
+  }): Identifiers[Model];
+}
+
+//#endregion
+//#region src/array.d.ts
+/**
+ * Adds a value to a sorted array and keeps the array sorted.
+ *
+ * O(n)
+ */
+declare function addAndSort<T>(arr: T[], value: T, predicate: (t: T) => number): T[];
+
+//#endregion
+//#region src/async.d.ts
+type AsyncMapFn<T, R> = (item: T, index: number) => Promise<R>;
+declare function mapLimit<T, R>(arr: T[], iterator: AsyncMapFn<T, R>, limit?: number): Promise<(R | undefined)[]>;
+
+//#endregion
+//#region src/buffer.d.ts
+/**
+ * Compares two string or buffer values for equality.
+ */
+declare function equals(a: string | Buffer, b: string | Buffer): boolean;
+
+//#endregion
+//#region src/datetime.d.ts
+/**
+ * returns the default time stamp in format YYMMDD HHMM
+ */
+declare function timeStamp(): string;
+/**
+ * Checks if a value is a valid Date object.
+ * Returns true only for Date instances that are not Invalid Date.
+ * This function is isomorphic and works in both Node.js and browser environments.
+ *
+ * @param value - The value to check
+ * @returns true if the value is a valid Date object, false otherwise
+ *
+ * @example
+ * isDate(new Date()) // true
+ * isDate(new Date('2023-01-01')) // true
+ * isDate(new Date('invalid')) // false (Invalid Date)
+ * isDate('2023-01-01') // false
+ * isDate(1234567890) // false
+ * isDate(null) // false
+ * isDate(undefined) // false
+ */
+declare function isDate(value: unknown): value is Date;
+
+//#endregion
+//#region src/dictionary.d.ts
+type Dictionary<Value, Key extends string = string> = Record<Key, Value>;
+declare function toDict<Value, Key extends string = string>(data: Value[], keyFn: (item: Value) => Key): Dictionary<Value, Key>;
+declare function idToDict<T extends {
+  id: string | number;
+}>(data: T[]): Dictionary<T>;
+declare function mapDict<S, T>(dict: Dictionary<S>, predicate: (item: S) => T): Dictionary<T>;
+declare function filterDict<T>(dict: Dictionary<T>, predicate: (item: T) => boolean): Dictionary<T>;
+declare function dictGetAndAssert<Key extends string, Value>(dict: Dictionary<Value>, key: Key): NonNullable<Value>;
+
+//#endregion
+//#region src/format.d.ts
+declare function format(n: number, locale?: string): string;
+
+//#endregion
+//#region src/group-by.d.ts
+declare const groupBy: <T, U extends string | number>(predicate: (x: T) => U, items: T[]) => Partial<Record<U, T[]>>;
+declare const groupByCurried: <T, U extends string | number>(predicate: (x: T) => U) => ((items: T[]) => Partial<Record<U, T[]>>);
+declare const groupByToDict: <Id extends string | number, WithId extends {
+  id: Id;
+}, GroupId extends string | number>(predicate: (x: WithId) => GroupId, items: WithId[]) => Partial<Record<GroupId, Record<Id, WithId>>>;
+declare const groupByToMap: <T extends {
+  id: ItemID;
+}, ItemID extends string | number, GroupID extends string | number>(getGroupId: (x: T) => GroupID, items: T[]) => Map<GroupID, Map<ItemID, T>>;
+
+//#endregion
+//#region src/map.d.ts
+declare function mapMap<Key, ValueFrom, ValueTo>(map: Map<Key, ValueFrom>, predicate: (item: ValueFrom, key: Key) => ValueTo): Map<Key, ValueTo>;
+declare function mapMapValues<Key, ValueFrom, ValueTo>(map: Map<Key, ValueFrom>, predicate: (item: ValueFrom, key: Key) => ValueTo): ValueTo[];
+/**
+ *
+ */
+declare function mapMapKeyValues<KeyFrom, KeyTo, ValueFrom, ValueTo>(map: Map<KeyFrom, ValueFrom>, keyPredicate: (key: KeyFrom, value: ValueFrom) => KeyTo, valuePredicate: (item: ValueFrom, key: KeyFrom) => ValueTo): Map<KeyTo, ValueTo>;
+/**
+ * Maps keys of a map.
+ */
+declare function mapMapKeys<KeyFrom, KeyTo, Value>(map: Map<KeyFrom, Value>, keyPredicate: (key: KeyFrom, value: Value) => KeyTo): Map<KeyTo, Value>;
+/**
+ * Filters values from a map.
+ */
+declare function filterMap<Key, Value>(map: Map<Key, Value>, predicate: (item: Value, key: Key) => boolean): Map<Key, Value>;
+/**
+ * Gets a value from a map and asserts that it exists.
+ */
+declare function mapGetAndAssert<Key, Value>(map: Map<Key, Value>, key: Key): Value;
+/**
+ * Converts a map to a dictionary.
+ */
+declare function mapToDict<Key extends string | number, Value>(map: Map<Key, Value>): Record<Key, Value>;
+
+//#endregion
+//#region src/omit.d.ts
+/**
+ * Omits a key from an object
+ */
+declare function omit<T extends Record<string, unknown>>(obj: T, key: string): Omit<T, typeof key>;
+
+//#endregion
+//#region src/pagination.d.ts
+type Page<Item> = {
+  total: number;
+  offset: number;
+  items: Item[];
+};
+declare const slice: <Item>(items: Item[], skip?: number, take?: number) => Page<Item>;
+
+//#endregion
+//#region src/random.d.ts
+/**
+ * Returns a random integer between 0 (inclusive) and max (exclusive).
+ *
+ * Isomorphic implementation for Node.js, Deno, Bun, and browser environments.
+ * Uses Web Crypto API which is available in all modern JavaScript runtimes.
+ */
+declare function randomInt(max: number): number;
+/**
+ * Returns a randomly generated alphanumeric string.
+ */
+declare function generateRandomAlphanumericString(length: number): string;
+
+//#endregion
+//#region src/remove-secrets.d.ts
+/**
+ * Removes secrets from the given configuration object.
+ *
+ * Recursively checks all properties of the object for keys that end with
+ * `key`, `secret`, `password`, `token` and replaces them with '***'.
+ *
+ * Also checks for keys the end with `connection` or `connectionString` and
+ * replaces the connection string with the same string but with the password
+ * replaced with '***'.
+ */
+declare function removeSecrets<T extends Record<string, unknown>>(config: T): T;
+
+//#endregion
+//#region src/remove-undefined.d.ts
+/**
+ * Removes all undefined properties from an object.
+ *
+ * NOTE: This is useful when using the `Partial<T>` type modifier in combination with the spread operator to prevent
+ *       overriding with undefined values.
+ */
+declare function removeUndefinedProperties<T extends Record<string, unknown>>(obj: T): { [K in keyof T]: T[K] extends undefined ? never : T[K] };
+
+//#endregion
+//#region src/result.d.ts
+type SerializedResult<A, E> = {
+  tag: 'ok';
+  value: A;
+} | {
+  tag: 'err';
+  err: E;
+};
+declare class Result<A, E> {
+  #private;
+  static ok<A, E>(value: A): Result<A, E>;
+  static err<A, E>(value: E): Result<A, E>;
+  static fromThrowable<A, E>(f: () => A, handleError: (error: Error) => E): Result<A, E>;
+  static fromObject<A, E>(result: SerializedResult<A, E>): Result<A, E>;
+  static fromPromise<A, E>(promise: () => Promise<A>, handleError: (error: Error) => E): Promise<Result<A, E>>;
+  private constructor();
+  private constructor();
+  isOk(): this is Result<A, never>;
+  isErr(): this is Result<never, E>;
+  map<B>(f: (a: A) => B): Result<B, E>;
+  mapErr<X>(f: (e: E) => X): Result<A, X>;
+  andThen<B>(f: (a: A) => Result<B, E>): Result<B, E>;
+  withDefault(fallback: A): A;
+  unwrap(): A;
+  unwrapErr(): E;
+  toJSON(): SerializedResult<A, E>;
+}
+declare const ok: typeof Result.ok;
+declare const err: typeof Result.err;
+type TypedError<T extends string> = {
+  type: T;
+  message: string;
+  error: Error;
+};
+
+//#endregion
+//#region src/sort.d.ts
+type CompareFn<T> = (a: T, b: T) => number;
+type Direction = 'asc' | 'desc';
+declare const sort: <Item>(items: Item[], dir?: Direction, compareFn?: CompareFn<Item>) => Item[];
+/**
+ * Compare fields of an object.
+ */
+declare const compareFields: <T>(key: keyof T) => CompareFn<T>;
+type Getter<T> = (data: T) => unknown;
+declare const compare: <T>(getter: Getter<T>) => CompareFn<T>;
+declare const keyGetter: <T>(key: keyof T) => Getter<T>;
+declare const compareValues: CompareFn<unknown>;
+declare const compareDates: CompareFn<Date>;
+declare const compareStrings: CompareFn<string>;
+declare const compareNumbers: CompareFn<number>;
+declare const compareBooleans: CompareFn<boolean>;
+declare const booleanCode: (bool: boolean) => number;
+declare const setDirection: <Item>(items: Item[], dir: Direction) => Item[];
+
+//#endregion
+//#region src/string-colors.d.ts
+/**
+ * A function that returns a string with a specific color.
+ */
+type ColorFn = (input: string) => string;
+/**
+ * Colors a string in red color (using ANSI escape codes).
+ */
+declare function red(input: string): string;
+/**
+ * Colors a string in green color (using ANSI escape codes).
+ */
+declare function green(input: string): string;
+/**
+ * Colors a string in yellow color (using ANSI escape codes).
+ */
+declare function yellow(input: string): string;
+/**
+ * Colors a string in blue color (using ANSI escape codes).
+ */
+declare function blue(input: string): string;
+/**
+ * Colors a string in cyan color (using ANSI escape codes).
+ */
+declare function cyan(input: string): string;
+/**
+ * Colors a string in gray color (using ANSI escape codes).
+ */
+declare function gray(input: string): string;
+/**
+ * Colors a string in bold color (using ANSI escape codes).
+ */
+declare function bold(input: string): string;
+/**
+ * Colors a string in underline color (using ANSI escape codes).
+ */
+declare function underline(input: string): string;
+/**
+ * Colors a string in italic color (using ANSI escape codes).
+ */
+declare function italic(input: string): string;
+/**
+ * Inverts the color of a string (using ANSI escape codes).
+ */
+declare function inverse(input: string): string;
+
+//#endregion
+//#region src/string.d.ts
+declare function upperFirst(s: string): string;
+declare function lowerFirst(s: string): string;
+/**
+ * Returns a pluralized version of the given string based on the count.
+ */
+declare function pluralize(s: string, count?: number): string;
+/**
+ * Returns true if the given string is already pluralized.
+ */
+declare function isPlural(s: string): boolean;
+/**
+ * Type modifier that converts all keys of an object to capitalized versions.
+ */
+type CapitalizedKeys<T extends Record<string, unknown>> = { [K in keyof T as CapitalizeFirstLetter<string & K>]: T[K] };
+/**
+ * Type modifier that converts the first letter of a string to a capital letter.
+ */
+type CapitalizeFirstLetter<S extends string> = `${Capitalize<Extract<S, string>>}`;
+/**
+ * Converts all keys of an object to capitalized versions in a type-safe way.
+ */
+declare function capitalizeKeys<T extends Record<string, unknown>>(obj: T): CapitalizedKeys<T>;
+/**
+ * Type modifier that converts all keys of an object to uncapitalized versions.
+ */
+type UncapitalizedKeys<T extends Record<string, unknown>> = { [K in keyof T as UncapitalizeFirstLetter<string & K>]: T[K] };
+/**
+ * Type modifier that converts the first letter of a string to an uncapitalized letter.
+ */
+type UncapitalizeFirstLetter<S extends string> = `${Uncapitalize<Extract<S, string>>}`;
+/**
+ * Converts all keys of an object to uncapitalized versions in a type-safe way.
+ */
+declare function uncapitalizeKeys<T extends Record<string, unknown>>(obj: T): UncapitalizedKeys<T>;
+/**
+ * Returns the same string with a lowercase first letter.
+ */
+declare function uncapitalize(str: string): string;
+/**
+ * Returns the same string with an uppercase first letter.
+ */
+declare function capitalize(str: string): string;
+/**
+ * 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'
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Validates if a string is in camelCase format
+ */
+declare function isCamelCase(str: string): boolean;
+/**
+ * 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'
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Validates if a string is in PascalCase format
+ */
+declare function isPascalCase(str: string): boolean;
+/**
+ * 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'
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Validates if a string is in snake_case format
+ */
+declare function isSnakeCase(str: string): boolean;
+/**
+ * Returns the kebab-case version of the given string.
+ *
+ * Examples:
+ *   `toKebabCase('hello world')` -> 'hello-world'
+ *   `toKebabCase('helloWorld')` -> 'hello-world'
+ *   `toKebabCase('HelloWorld')` -> 'hello-world'
+ *   `toKebabCase('HELLO_WORLD')` -> 'hello-world'
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Validates if a string is in kebab-case format
+ */
+declare function isKebabCase(str: string): boolean;
+/**
+ * Converts each line of a string to a commented line
+ */
+declare function commentLines(lines: string): string;
+declare function toHumanReadable(input: string): string;
+/**
+ * Sanitizes a string to be a valid Excel ListObject (table) column name.
+ * - Removes illegal characters: [ ] : ? * / \
+ * - Trims leading/trailing spaces
+ * - Replaces multiple spaces with a single space
+ * - If the result is empty, returns a default name
+ */
+declare function toExcelColumnName(input: string, defaultName?: string): string;
+/**
+ * Sanitizes a string to be a valid Excel ListObject (table) name.
+ * - Must start with a letter, underscore, or backslash
+ * - Only letters, numbers, and underscores allowed (no spaces or punctuation)
+ * - Cannot be a cell reference (e.g., "A1")
+ * - Max 255 characters
+ * - If invalid or empty, returns a default name
+ */
+declare function toExcelTableName(input: string, defaultName?: string): string;
+type Conjugated = {
+  camelCase: string;
+  camelCasePlural: string;
+  capitalized: string;
+  capitalizedPlural: string;
+  kebabCase: string;
+  kebabCasePlural: string;
+  PascalCase: string;
+  PascalCasePlural: string;
+  pluralized: string;
+  snake_case_plural: string;
+  snake_case: string;
+  uncapitalized: string;
+  uncapitalizedPlural: string;
+};
+/**
+ * Provide all relevant conjugation of a name
+ */
+declare function conjugateNames(name: string): Conjugated;
+declare function slugify(str: string): string;
+declare function isSlug(str: string): boolean;
+/**
+ * Ensures that a string is unique within a list of existing values by appending a sequential number if necessary.
+ *
+ * If the base string is not in the list, it is returned as is.
+ * If it is, the function looks for existing strings in the format "base (n)" where n is a number,
+ * and returns the next available sequential string.
+ *
+ * @param value - The base string to ensure uniqueness for.
+ * @param existingValues - An array of existing strings to check against.
+ * @param maxChecks - Maximum number of checks to be performed. An error is thrown if this limit is exceeded. Default is 100
+ * @returns A unique string based on the base string.
+ */
+declare const ensureUnique: (value: string, existingValues: string[], maxChecks?: number) => string;
+
+//#endregion
+//#region src/types.d.ts
+type Without<T, U> = Partial<Record<Exclude<keyof T, keyof U>, never>>;
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+type Exact<T, I> = T extends I ? (Exclude<keyof T, keyof I> extends never ? T : never) : never;
+type UncapitalizeObjectKeys<T> = { [key in keyof T as Uncapitalize<key & string>]: T[key] };
+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" }
+ */
+type UnionPick<T, K extends keyof T> = T extends unknown ? Pick<T, K> : never;
+/**
+ * Like UnionPick, but for Omit
+ */
+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.
+ */
+declare class ExhaustiveSwitchCheck extends Error {
+  constructor(val: never);
+}
+/**
+ * A type that represents an array that is guaranteed to have at least one element.
+ */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Converts a nested object to a nested object where all properties are optional.
+ */
+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 }
+ */
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Allows inline type assertions.
+ *
+ * Example:
+ * ```
+ * type Original = { a: number }
+ * type WithExtra = Original & { b: string }
+ *
+ * function addExtra(obj: Original): asserts obj is WithExtra {
+ *   assertType(obj)
+ *   obj.b = 'new value' // ✅ No TypeScript error!
+ * }
+ * ```
+ */
+declare function assertType<T>(value: unknown): asserts value is T;
+/**
+ * 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!
+ * ```
+ */
+declare function assertArray<I, O extends I>(obj: I[], fn: (i: I) => asserts i is O): asserts obj is O[];
+/**
+ * Converts any branded string type to its underlying string type.
+ */
+type Debrand<T> = T extends string & infer _U ? string : T extends object ? { [K in keyof T]: Debrand<T[K]> } : T;
+
+//#endregion
+//#region src/uniq.d.ts
+declare function uniq<T>(items: T[], predicate: (item: T) => number): T[];
+
+//#endregion
+//#region src/zod.d.ts
+type Transformer<Input, Output> = (value: Input, ctx: z.RefinementCtx) => Output | z.ZodNever;
+type ReturnTypeOfLast<T extends any[]> = T extends [...any, infer L] ? L extends ((...args: any) => any) ? ReturnType<L> : never : never;
+/**
+ * Pipes a list of Zod transformers together in a type-safe way. Returns early if any of the transformers returns `z.NEVER`.
+ */
+declare function pipeZodTransformers<Initial, Fns extends [Transformer<any, any>, ...Transformer<any, any>[]]>(initialValue: Initial, ctx: z.RefinementCtx, fns: Fns): ReturnTypeOfLast<Fns>;
+/**
+ * Returns a Zod error callback that returns the given message for union errors.
+ *
+ * This is useful for generating meaningful error messages for unions, e.g.
+ * ```
+ * z.union(
+ *   [z.constant('foo'), z.constant('bar')],
+ *   unionErrorMessage('Value must be either "foo" or "bar"!')
+ * )
+ * ```
+ *
+ * In addition to a static message, you can also pass a function that takes the
+ * invalid data as input and returns a string. Example:
+ * ```
+ * z.union(
+ *   [z.constant('foo'), z.constant('bar')],
+ *   unionErrorMessage((data) => `Value must be either "foo" or "bar" - received ${JSON.stringify(data)} instead!`)
+ * )
+ * ```
+ */
+declare function unionErrorMessage(param: string | ((data: unknown) => string)): {
+  error: (issue: any) => string;
+};
+
+//#endregion
+//#region src/zod-excel.decoders.d.ts
+/**
+ * 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!
+ */
+declare const excelStringStrictDecoder: z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber, z$1.ZodBoolean]>, z$1.ZodTransform<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
+ *
+ * Null handling: Null values/blank cells will be converted to a blank string.
+ */
+declare const excelStringDecoder: z$1.ZodPipe<z$1.ZodTransform<string, unknown>, z$1.ZodString>;
+/**
+ * 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 - except blank strings, which will be converted to null
+ * - 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
+ *
+ * Null handling: Blank strings will be converted to null. This is to reflect that in Excel a formula
+ *   cannot return null. As a workaround, one often returns a blank string to represent null.
+ */
+declare const excelStringNullableDecoder: z$1.ZodPipe<z$1.ZodTransform<string | null, unknown>, z$1.ZodNullable<z$1.ZodString>>;
+/**
+ * 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
+ *
+ */
+declare const excelNumberStrictDecoder: z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber, z$1.ZodBoolean]>, z$1.ZodTransform<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
+ *
+ * Null handling: Null values/blank cells will be converted to blank strings.
+ */
+declare const excelNumberDecoder: z$1.ZodPipe<z$1.ZodTransform<number, unknown>, z$1.ZodNumber>;
+/**
+ * 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. Non-numerical and blank strings will be converted to null
+ * - If the value is boolean, it'll return 1 or 0
+ * - If the value is any other type, it'll return null
+ *
+ * Null handling: Blank strings will be converted to null. This is to reflect that in Excel a formula
+ *   cannot return null. As a workaround, one often returns a blank string to represent null.
+ */
+declare const excelNumberNullableDecoder: z$1.ZodPipe<z$1.ZodTransform<number | null, any>, z$1.ZodNullable<z$1.ZodNumber>>;
+/**
+ * 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.
+ */
+declare const excelIntStrictDecoder: z$1.ZodPipe<z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber, z$1.ZodBoolean]>, z$1.ZodTransform<number, string | number | boolean>>, z$1.ZodTransform<number, number>>;
+/**
+ * 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.
+ */
+declare const excelIntDecoder: z$1.ZodPipe<z$1.ZodPipe<z$1.ZodTransform<number, unknown>, z$1.ZodNumber>, z$1.ZodTransform<number, number>>;
+/**
+ * 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.
+ */
+declare const excelIntNullableDecoder: z$1.ZodPipe<z$1.ZodPipe<z$1.ZodTransform<number | null, any>, z$1.ZodNullable<z$1.ZodNumber>>, z$1.ZodTransform<number | null, number | null>>;
+/**
+ * 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.
+ */
+declare const excelBigIntStrictDecoder: z$1.ZodPipe<z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber, z$1.ZodBoolean]>, z$1.ZodTransform<number, string | number | boolean>>, z$1.ZodTransform<bigint, number>>;
+/**
+ * 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.
+ */
+declare const excelBigIntDecoder: z$1.ZodPipe<z$1.ZodPipe<z$1.ZodTransform<number, unknown>, z$1.ZodNumber>, z$1.ZodTransform<bigint, number>>;
+/**
+ * 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.
+ */
+declare const excelBigIntNullableDecoder: z$1.ZodPipe<z$1.ZodPipe<z$1.ZodTransform<number | null, any>, z$1.ZodNullable<z$1.ZodNumber>>, z$1.ZodTransform<bigint | null, number | null>>;
+/**
+ * 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
+ */
+declare const excelBooleanStrictDecoder: z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodBoolean, z$1.ZodNumber, z$1.ZodString]>, z$1.ZodTransform<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
+ */
+declare const excelBooleanDecoder: z$1.ZodPipe<z$1.ZodTransform<boolean, unknown>, z$1.ZodBoolean>;
+/**
+ * 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
+ */
+declare const excelBooleanNullableDecoder: z$1.ZodPipe<z$1.ZodTransform<boolean | null, any>, z$1.ZodNullable<z$1.ZodBoolean>>;
+/**
+ * A decoder that transforms Excel dates to JS Dates
+ */
+declare const excelDateDecoder: z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodDate, z$1.ZodNumber, z$1.ZodString]>, z$1.ZodTransform<Date, string | number | Date>>;
+/**
+ * A decoder that transforms nullable Excel dates to JS Dates
+ */
+declare const excelDateNullableDecoder: z$1.ZodPipe<z$1.ZodTransform<Date | null, unknown>, z$1.ZodNullable<z$1.ZodDate>>;
+
+//#endregion
+export { CapitalizedKeys, ColorFn, CompareFn, Conjugated, Debrand, DeepPartial, DefaultMap as DefaultMap$1, Dictionary, Direction, Exact, ExhaustiveSwitchCheck as ExhaustiveSwitchCheck$1, Getter, NestedMap as NestedMap$1, NonEmptyArray, Optional, Page, Prettify, Result as Result$1, SerializedResult, Transformer, TypedError, TypedMapping as TypedMapping$1, UncapitalizeObjectKeys, UncapitalizedKeys, UnionOmit, UnionPick, XOR, addAndSort as addAndSort$1, assertArray as assertArray$1, assertType as assertType$1, blue as blue$1, bold as bold$1, booleanCode as booleanCode$1, capitalize as capitalize$1, capitalizeKeys as capitalizeKeys$1, commentLines as commentLines$1, compare as compare$1, compareBooleans as compareBooleans$1, compareDates as compareDates$1, compareFields as compareFields$1, compareNumbers as compareNumbers$1, compareStrings as compareStrings$1, compareValues as compareValues$1, conjugateNames as conjugateNames$1, cyan as cyan$1, dictGetAndAssert as dictGetAndAssert$1, ensureUnique as ensureUnique$1, equals as equals$1, err as err$1, excelBigIntDecoder as excelBigIntDecoder$1, excelBigIntNullableDecoder as excelBigIntNullableDecoder$1, excelBigIntStrictDecoder as excelBigIntStrictDecoder$1, excelBooleanDecoder as excelBooleanDecoder$1, excelBooleanNullableDecoder as excelBooleanNullableDecoder$1, excelBooleanStrictDecoder as excelBooleanStrictDecoder$1, excelDateDecoder as excelDateDecoder$1, excelDateNullableDecoder as excelDateNullableDecoder$1, excelIntDecoder as excelIntDecoder$1, excelIntNullableDecoder as excelIntNullableDecoder$1, excelIntStrictDecoder as excelIntStrictDecoder$1, excelNumberDecoder as excelNumberDecoder$1, excelNumberNullableDecoder as excelNumberNullableDecoder$1, excelNumberStrictDecoder as excelNumberStrictDecoder$1, excelStringDecoder as excelStringDecoder$1, excelStringNullableDecoder as excelStringNullableDecoder$1, excelStringStrictDecoder as excelStringStrictDecoder$1, filterDict as filterDict$1, filterMap as filterMap$1, format as format$1, generateRandomAlphanumericString as generateRandomAlphanumericString$1, gray as gray$1, green as green$1, groupBy as groupBy$1, groupByCurried as groupByCurried$1, groupByToDict as groupByToDict$1, groupByToMap as groupByToMap$1, idToDict as idToDict$1, inverse as inverse$1, isCamelCase as isCamelCase$1, isDate as isDate$1, isKebabCase as isKebabCase$1, isPascalCase as isPascalCase$1, isPlural as isPlural$1, isSlug as isSlug$1, isSnakeCase as isSnakeCase$1, italic as italic$1, keyGetter as keyGetter$1, lowerFirst as lowerFirst$1, mapDict as mapDict$1, mapGetAndAssert as mapGetAndAssert$1, mapLimit as mapLimit$1, mapMap as mapMap$1, mapMapKeyValues as mapMapKeyValues$1, mapMapKeys as mapMapKeys$1, mapMapValues as mapMapValues$1, mapToDict as mapToDict$1, ok as ok$1, omit as omit$1, pipeZodTransformers as pipeZodTransformers$1, pluralize as pluralize$1, randomInt as randomInt$1, red as red$1, removeSecrets as removeSecrets$1, removeUndefinedProperties as removeUndefinedProperties$1, setDirection as setDirection$1, slice as slice$1, slugify as slugify$1, sort as sort$1, timeStamp as timeStamp$1, toCamelCase as toCamelCase$1, toDict as toDict$1, toExcelColumnName as toExcelColumnName$1, toExcelTableName as toExcelTableName$1, toHumanReadable as toHumanReadable$1, toKebabCase as toKebabCase$1, toPascalCase as toPascalCase$1, toSnakeCase as toSnakeCase$1, uncapitalize as uncapitalize$1, uncapitalizeKeys as uncapitalizeKeys$1, underline as underline$1, unionErrorMessage as unionErrorMessage$1, uniq as uniq$1, upperFirst as upperFirst$1, yellow as yellow$1 };
+//# sourceMappingURL=zod-excel.decoders-CtmUu_Yj.d.ts.map