sizuku 0.0.7 → 0.2.0

package/dist/shared/helper/extract-schemas.js

@@ -0,0 +1,445 @@
+import { Node, Project } from 'ts-morph';
+import { capitalize, containsSubstring, extractFieldComments, parseFieldComments, removeOptionalSuffix, splitByDot, splitByTo, splitByWhitespace, startsWith, trimString, } from '../../utils/index.js';
+/**
+ * Generates relation definition based on function name and reference table.
+ *
+ * @param fnName - The relation function name ('many' or 'one')
+ * @param refTable - The referenced table name
+ * @param prefix - Schema prefix ('v' or 'z') for validation library
+ * @returns The generated relation definition string
+ */
+function generateRelationDefinition(fnName, refTable, prefix) {
+    const schema = `${capitalize(refTable)}Schema`;
+    return fnName === 'many' ? `${prefix}.array(${schema})` : fnName === 'one' ? schema : '';
+}
+/**
+ * Processes arrow function body to find object literal expression.
+ *
+ * @param body - The arrow function body node
+ * @returns The found object literal expression, or null if not found
+ */
+function processArrowFunctionBody(body) {
+    if (Node.isObjectLiteralExpression(body))
+        return body;
+    if (Node.isParenthesizedExpression(body)) {
+        return findObjectLiteralExpression(body.getExpression());
+    }
+    if (Node.isBlock(body)) {
+        const ret = body.getStatements().find(Node.isReturnStatement);
+        if (ret && Node.isReturnStatement(ret)) {
+            const re = ret.getExpression();
+            return re && Node.isObjectLiteralExpression(re) ? re : null;
+        }
+    }
+    return null;
+}
+/**
+ * Recursively extracts an `ObjectLiteralExpression` from a given AST node.
+ *
+ * @param expr - The root `Node` to search for object literals
+ * @returns The found `ObjectLiteralExpression`, or `null` if not found
+ */
+function findObjectLiteralExpression(expr) {
+    if (Node.isObjectLiteralExpression(expr))
+        return expr;
+    if (Node.isParenthesizedExpression(expr)) {
+        return findObjectLiteralExpression(expr.getExpression());
+    }
+    if (Node.isArrowFunction(expr)) {
+        return processArrowFunctionBody(expr.getBody());
+    }
+    return null;
+}
+/**
+ * Finds an object literal expression in call expression arguments.
+ *
+ * @param call - The call expression to search for object literals in its arguments
+ * @param finder - Function to find object literal in a node
+ * @returns The found object literal, or `null` if not found in any argument
+ */
+function findObjectLiteralInArgs(call, finder) {
+    for (const arg of call.getArguments()) {
+        const obj = finder(arg);
+        if (obj)
+            return obj;
+    }
+    return null;
+}
+/**
+ * Determines whether a given `CallExpression` is a relation-related function call.
+ *
+ * @param callExpr - The call expression node to check for relation functions
+ * @returns `true` if the function is a relation function; otherwise, `false`
+ */
+function isRelationFunctionCall(callExpr) {
+    const expression = callExpr.getExpression();
+    if (!Node.isIdentifier(expression))
+        return false;
+    const functionName = expression.getText();
+    return functionName === 'relations' || functionName.includes('relation');
+}
+/**
+ * Creates a field extractor function using a custom parseFieldComments implementation.
+ *
+ * @param parseFieldComments - A function that parses comment lines into { definition, description, objectType }
+ * @returns A property node extractor function
+ */
+function createExtractFieldFromProperty(parseFieldComments) {
+    return (property, sourceText) => {
+        if (!Node.isPropertyAssignment(property))
+            return null;
+        const name = property.getName();
+        if (!name)
+            return null;
+        const commentLines = extractFieldComments(sourceText, property.getStart());
+        const { definition, description } = parseFieldComments(commentLines);
+        return { name, definition, description };
+    };
+}
+/**
+ * Creates a relation field extractor function.
+ *
+ * @param parseFieldComments - Function to parse field comments
+ * @param prefix - Schema prefix ('v' or 'z') for validation library
+ * @returns Function that extracts relation fields from property
+ */
+function createExtractRelationFieldFromProperty(parseFieldComments, prefix) {
+    return (property, sourceText) => {
+        if (!Node.isPropertyAssignment(property))
+            return null;
+        const name = property.getName();
+        if (!name)
+            return null;
+        const init = property.getInitializer();
+        if (!Node.isCallExpression(init)) {
+            return { name, definition: '', description: undefined };
+        }
+        const expr = init.getExpression();
+        if (!Node.isIdentifier(expr)) {
+            return { name, definition: '', description: undefined };
+        }
+        const fnName = expr.getText();
+        const args = init.getArguments();
+        if (!(args.length && Node.isIdentifier(args[0]))) {
+            return { name, definition: '', description: undefined };
+        }
+        const refTable = args[0].getText();
+        const definition = generateRelationDefinition(fnName, refTable, prefix);
+        const { description } = parseFieldComments(extractFieldComments(sourceText, property.getStart()));
+        return { name, definition, description };
+    };
+}
+/**
+ * Extracts fields from object literal properties using appropriate extractor.
+ *
+ * @param properties - Array of object literal properties
+ * @param isRelation - Whether this is a relation function call
+ * @param extractFieldFromProperty - Function to extract regular fields
+ * @param extractRelationFieldFromProperty - Function to extract relation fields
+ * @param sourceText - The source text for comment extraction
+ * @returns Array of extracted field results
+ */
+function extractFieldsFromProperties(properties, isRelation, extractFieldFromProperty, extractRelationFieldFromProperty, sourceText) {
+    return properties
+        .map((prop) => isRelation
+        ? extractRelationFieldFromProperty(prop, sourceText)
+        : extractFieldFromProperty(prop, sourceText))
+        .filter((field) => field !== null);
+}
+/**
+ * Creates a field extractor for call expressions with customizable strategies.
+ *
+ * @param extractFieldFromProperty - Function to extract field from property
+ * @param extractRelationFieldFromProperty - Function to extract relation field from property
+ * @param findObjectLiteralExpression - Function to find object literal expression
+ * @param findObjectLiteralInArgs - Function to find object literal in call arguments
+ * @param isRelationFunctionCall - Function to check if call is relation function
+ * @returns Function that extracts fields from call expression
+ */
+function createExtractFieldsFromCallExpression(extractFieldFromProperty, extractRelationFieldFromProperty, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall) {
+    return (callExpr, sourceText) => {
+        const objectLiteral = findObjectLiteralInArgs(callExpr, findObjectLiteralExpression);
+        if (!objectLiteral)
+            return [];
+        const isRelation = isRelationFunctionCall(callExpr);
+        const properties = objectLiteral.getProperties();
+        return extractFieldsFromProperties(properties, isRelation, extractFieldFromProperty, extractRelationFieldFromProperty, sourceText);
+    };
+}
+/**
+ * Creates a schema extractor from customizable strategies.
+ *
+ * @param extractFieldsFromCall - Function to extract fields from a call expression
+ * @param extractFieldFromProperty - Function to extract a single field from an object literal property
+ * @param parseFieldComments - Function to parse field comments with object type support
+ * @param commentPrefix - The comment prefix to use for parsing
+ * @returns A function that extracts a schema from a variable declaration node
+ */
+function buildSchemaExtractor(extractFieldsFromCall, extractFieldFromProperty, parseFieldComments, commentPrefix) {
+    return (variableStatement, sourceText, originalSourceCode) => {
+        if (!Node.isVariableStatement(variableStatement))
+            return null;
+        const declarations = variableStatement.getDeclarations();
+        if (declarations.length === 0)
+            return null;
+        const declaration = declarations[0];
+        const name = declaration.getName();
+        if (!name)
+            return null;
+        // Extract object type from table-level comments
+        // Since ts-morph doesn't capture all comments properly, we'll parse the original source
+        const statementStart = variableStatement.getStart();
+        const originalSourceLines = originalSourceCode.split('\n'); // Use original source, not AST sourceText
+        const commentLines = [];
+        // Find the line number where this statement starts
+        let lineNumber = 0;
+        let charCount = 0;
+        for (let i = 0; i < originalSourceLines.length; i++) {
+            if (charCount >= statementStart) {
+                lineNumber = i;
+                break;
+            }
+            charCount += originalSourceLines[i].length + 1; // +1 for newline
+        }
+        // Collect comments immediately before the statement
+        for (let i = lineNumber - 1; i >= 0; i--) {
+            const line = originalSourceLines[i];
+            const trimmedLine = trimString(line);
+            // Skip empty lines
+            if (trimmedLine === '')
+                continue;
+            // If it's a comment line, add it to our collection
+            if (startsWith(trimmedLine, '///')) {
+                commentLines.unshift(line);
+            }
+            else {
+                // If we hit a non-comment line, stop collecting
+                break;
+            }
+        }
+        const { objectType } = parseFieldComments(commentLines, commentPrefix);
+        const initializer = declaration.getInitializer();
+        if (Node.isCallExpression(initializer)) {
+            if (isRelationFunctionCall(initializer))
+                return null;
+            const fields = extractFieldsFromCall(initializer, sourceText);
+            return { name, fields, objectType };
+        }
+        if (Node.isObjectLiteralExpression(initializer)) {
+            const fields = initializer
+                .getProperties()
+                .map((prop) => extractFieldFromProperty(prop, sourceText))
+                .filter((field) => field !== null);
+            return { name, fields, objectType };
+        }
+        return { name, fields: [], objectType };
+    };
+}
+/**
+ * Extracts schemas from TypeScript source code using AST analysis.
+ *
+ * This function processes exported variable declarations to extract table schemas
+ * with their field definitions and comments. It supports both Zod and Valibot schema extraction.
+ *
+ * @param lines - Array of source code lines to process
+ * @param library - The validation library to extract schemas for ('zod' or 'valibot')
+ * @returns Array of extracted schemas with field definitions
+ *
+ * @example
+ * ```typescript
+ * // For Zod schemas
+ * const zodSchemas = extractSchemas(sourceLines, 'zod')
+ *
+ * // For Valibot schemas
+ * const valibotSchemas = extractSchemas(sourceLines, 'valibot')
+ * ```
+ */
+export function extractSchemas(lines, library) {
+    const sourceCode = lines.join('\n');
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            allowJs: true,
+            skipLibCheck: true,
+        },
+    });
+    const sourceFile = project.createSourceFile('temp.ts', sourceCode);
+    const sourceText = sourceFile.getFullText();
+    const commentPrefix = library === 'zod' ? '@z.' : '@v.';
+    const schemaPrefix = library === 'zod' ? 'z' : 'v';
+    const extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix));
+    const extractRelationField = createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix), schemaPrefix);
+    const extractFieldsFromCall = createExtractFieldsFromCallExpression(extractField, extractRelationField, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall);
+    const extractSchema = buildSchemaExtractor(extractFieldsFromCall, extractField, parseFieldComments, commentPrefix);
+    return sourceFile
+        .getVariableStatements()
+        .filter((stmt) => stmt.hasExportKeyword())
+        .map((stmt) => extractSchema(stmt, sourceText, sourceCode))
+        .filter((schema) => schema !== null);
+}
+/**
+ * Extracts Zod schemas from TypeScript source code using AST analysis.
+ *
+ * This function processes exported variable declarations to extract table schemas
+ * with their field definitions and comments. It automatically handles Zod schema extraction.
+ *
+ * @param lines - Array of source code lines to process
+ * @returns Array of extracted schemas with field definitions
+ *
+ * @example
+ * ```typescript
+ * const schemas = extractZodSchemas(sourceLines)
+ * // Returns: [{ name: 'user', fields: [{ name: 'id', definition: 'z.uuid()', description: 'Primary key' }] }]
+ * ```
+ */
+export function extractZodSchemas(lines) {
+    return extractSchemas(lines, 'zod');
+}
+/**
+ * Extracts Valibot schemas from TypeScript source code using AST analysis.
+ *
+ * This function processes exported variable declarations to extract table schemas
+ * with their field definitions and comments. It automatically handles Valibot schema extraction.
+ *
+ * @param lines - Array of source code lines to process
+ * @returns Array of extracted schemas with field definitions
+ *
+ * @example
+ * ```typescript
+ * const schemas = extractValibotSchemas(sourceLines)
+ * // Returns: [{ name: 'user', fields: [{ name: 'id', definition: 'v.pipe(v.string(), v.uuid())', description: 'Primary key' }] }]
+ * ```
+ */
+export function extractValibotSchemas(lines) {
+    return extractSchemas(lines, 'valibot');
+}
+/**
+ * Extracts relation schemas from `relations(...)` declarations using AST analysis.
+ *
+ * This returns entries like `userRelations` and `postRelations` with fields
+ * resolved to either `z.array(OtherSchema)` / `v.array(OtherSchema)` or direct
+ * `OtherSchema` based on `many`/`one`.
+ *
+ * Note: Base table schemas are not included here; use `extractSchemas` for those.
+ */
+export function extractRelationSchemas(lines, library) {
+    const sourceCode = lines.join('\n');
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: { allowJs: true, skipLibCheck: true },
+    });
+    const sourceFile = project.createSourceFile('temp.ts', sourceCode);
+    const sourceText = sourceFile.getFullText();
+    const commentPrefix = library === 'zod' ? '@z.' : '@v.';
+    const schemaPrefix = library === 'zod' ? 'z' : 'v';
+    // First, extract base schemas to get their objectType
+    const baseSchemas = extractSchemas(lines, library);
+    const baseSchemaMap = new Map(baseSchemas.map((schema) => [schema.name, schema.objectType]));
+    const extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix));
+    const extractRelationField = createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix), schemaPrefix);
+    const extractFieldsFromCall = createExtractFieldsFromCallExpression(extractField, extractRelationField, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall);
+    function extract(declaration) {
+        if (!Node.isVariableDeclaration(declaration))
+            return null;
+        const name = declaration.getName();
+        if (!name)
+            return null;
+        const initializer = declaration.getInitializer();
+        if (!Node.isCallExpression(initializer))
+            return null;
+        if (!isRelationFunctionCall(initializer))
+            return null;
+        const relArgs = initializer.getArguments();
+        const baseIdentifier = relArgs.length && Node.isIdentifier(relArgs[0]) ? relArgs[0] : undefined;
+        if (!baseIdentifier)
+            return null;
+        const baseName = baseIdentifier.getText();
+        const fields = extractFieldsFromCall(initializer, sourceText);
+        // Inherit objectType from the base schema
+        const objectType = baseSchemaMap.get(baseName);
+        return { name, baseName, fields, objectType };
+    }
+    return sourceFile
+        .getVariableStatements()
+        .filter((stmt) => stmt.hasExportKeyword())
+        .flatMap((stmt) => stmt.getDeclarations())
+        .map((decl) => extract(decl))
+        .filter((schema) => schema !== null);
+}
+/**
+ * Extracts relations from the given code.
+ *
+ * @param code - The code to extract relations from.
+ * @returns The extracted relations.
+ */
+export function extractRelations(code) {
+    const relations = [];
+    for (const line of code) {
+        const relation = parseRelationLine(line);
+        if (relation) {
+            relations.push(relation);
+        }
+    }
+    return relations;
+}
+/**
+ * Parse relation line and extract components.
+ *
+ * @param line - The line to parse.
+ * @returns Parsed relation or null if not a relation line.
+ */
+export function parseRelationLine(line) {
+    const trimmedLine = trimString(line);
+    const cleanLine = startsWith(trimmedLine, '///') ? trimmedLine.substring(3) : trimmedLine;
+    const finalLine = trimString(cleanLine);
+    if (!startsWith(finalLine, '@relation'))
+        return null;
+    const parts = splitByWhitespace(finalLine);
+    if (parts.length < 4)
+        return null;
+    const fromParts = splitByDot(parts[1]);
+    const toParts = splitByDot(parts[2]);
+    if (fromParts.length !== 2 || toParts.length !== 2)
+        return null;
+    return {
+        fromModel: fromParts[0],
+        fromField: fromParts[1],
+        toModel: toParts[0],
+        toField: toParts[1],
+        type: parts[3],
+    };
+}
+/**
+ * Build a relation line from a string.
+ *
+ * @param input - The input string.
+ * @returns The built relation line.
+ */
+export function buildRelationLine(input) {
+    const toSymbol = (r) => r === 'zero-one'
+        ? '|o'
+        : r === 'one'
+            ? '||'
+            : r === 'zero-many'
+                ? '}o'
+                : r === 'many'
+                    ? '}|'
+                    : (() => {
+                        throw new Error(`Invalid relationship: ${r}`);
+                    })();
+    const isRelationship = (r) => ['zero-one', 'one', 'zero-many', 'many'].includes(r);
+    const parts = splitByTo(input);
+    if (!parts)
+        throw new Error(`Invalid input format: ${input}`);
+    const [fromRaw, toRawWithOptional] = parts;
+    const [toRaw, isOptional] = containsSubstring(toRawWithOptional, '-optional')
+        ? [removeOptionalSuffix(toRawWithOptional), true]
+        : [toRawWithOptional, false];
+    if (!(isRelationship(fromRaw) && isRelationship(toRaw))) {
+        throw new Error(`Invalid relationship string: ${input}`);
+    }
+    const fromSymbol = toSymbol(fromRaw);
+    const toSymbolStr = toSymbol(toRaw);
+    const connector = isOptional ? '..' : '--';
+    return `${fromSymbol}${connector}${toSymbolStr}`;
+}

package/dist/shared/helper/file-writer.d.ts

@@ -0,0 +1,3 @@
+import { Result } from 'neverthrow';
+export declare const writeFileSafely: (filePath: string, content: string) => Promise<Result<void, Error>>;
+export declare const ensureDirectoryExists: (directory: string) => Promise<Result<void, Error>>;

package/dist/shared/helper/file-writer.js

@@ -0,0 +1,25 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+import { Result, err, ok } from 'neverthrow';
+export const writeFileSafely = async (filePath, content) => {
+    try {
+        // ディレクトリが存在しない場合は作成
+        const directory = dirname(filePath);
+        await mkdir(directory, { recursive: true });
+        // ファイルを書き込み
+        await writeFile(filePath, content, 'utf-8');
+        return ok(undefined);
+    }
+    catch (error) {
+        return err(new Error(`Failed to write file ${filePath}: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+export const ensureDirectoryExists = async (directory) => {
+    try {
+        await mkdir(directory, { recursive: true });
+        return ok(undefined);
+    }
+    catch (error) {
+        return err(new Error(`Failed to create directory ${directory}: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};

package/dist/shared/helper/find-object-literal-expression.d.ts

@@ -0,0 +1,12 @@
+import type { ObjectLiteralExpression } from 'ts-morph';
+import { Node } from 'ts-morph';
+/**
+ * Recursively extracts an `ObjectLiteralExpression` from a given AST node.
+ *
+ * Supports direct object literals, parenthesized expressions,
+ * arrow functions returning object literals (including wrapped and block bodies).
+ *
+ * @param expr - The root `Node` to search.
+ * @returns The found `ObjectLiteralExpression`, or `null` if not found.
+ */
+export declare function findObjectLiteralExpression(expr: Node): ObjectLiteralExpression | null;

package/dist/shared/helper/find-object-literal-expression.js

@@ -0,0 +1,31 @@
+import { Node } from 'ts-morph';
+/**
+ * Recursively extracts an `ObjectLiteralExpression` from a given AST node.
+ *
+ * Supports direct object literals, parenthesized expressions,
+ * arrow functions returning object literals (including wrapped and block bodies).
+ *
+ * @param expr - The root `Node` to search.
+ * @returns The found `ObjectLiteralExpression`, or `null` if not found.
+ */
+export function findObjectLiteralExpression(expr) {
+    if (Node.isObjectLiteralExpression(expr))
+        return expr;
+    if (Node.isParenthesizedExpression(expr))
+        return findObjectLiteralExpression(expr.getExpression());
+    if (Node.isArrowFunction(expr)) {
+        const body = expr.getBody();
+        if (Node.isObjectLiteralExpression(body))
+            return body;
+        if (Node.isParenthesizedExpression(body))
+            return findObjectLiteralExpression(body.getExpression());
+        if (Node.isBlock(body)) {
+            const ret = body.getStatements().find(Node.isReturnStatement);
+            if (ret && Node.isReturnStatement(ret)) {
+                const re = ret.getExpression();
+                return re && Node.isObjectLiteralExpression(re) ? re : null;
+            }
+        }
+    }
+    return null;
+}

package/dist/shared/helper/find-object-literalIn-args.d.ts

@@ -0,0 +1,2 @@
+import type { CallExpression, Node, ObjectLiteralExpression } from 'ts-morph';
+export declare function findObjectLiteralInArgs(call: CallExpression, finder: (expr: Node) => ObjectLiteralExpression | null): ObjectLiteralExpression | null;

package/dist/shared/helper/find-object-literalIn-args.js

@@ -0,0 +1,8 @@
+export function findObjectLiteralInArgs(call, finder) {
+    for (const arg of call.getArguments()) {
+        const obj = finder(arg);
+        if (obj)
+            return obj;
+    }
+    return null;
+}

package/dist/shared/helper/is-relation-function.d.ts

@@ -0,0 +1,10 @@
+import type { CallExpression } from 'ts-morph';
+/**
+ * Determines whether a given `CallExpression` is a relation-related function call.
+ *
+ * This checks if the function name is either `"relations"` or contains the substring `"relation"`.
+ *
+ * @param callExpr - The call expression node to check.
+ * @returns `true` if the function is a relation function; otherwise, `false`.
+ */
+export declare function isRelationFunctionCall(callExpr: CallExpression): boolean;

package/dist/shared/helper/is-relation-function.js

@@ -0,0 +1,16 @@
+import { Node } from 'ts-morph';
+/**
+ * Determines whether a given `CallExpression` is a relation-related function call.
+ *
+ * This checks if the function name is either `"relations"` or contains the substring `"relation"`.
+ *
+ * @param callExpr - The call expression node to check.
+ * @returns `true` if the function is a relation function; otherwise, `false`.
+ */
+export function isRelationFunctionCall(callExpr) {
+    const expression = callExpr.getExpression();
+    if (!Node.isIdentifier(expression))
+        return false;
+    const functionName = expression.getText();
+    return functionName === 'relations' || functionName.includes('relation');
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{common/text → shared/utils}/capitalize.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.capitalize = capitalize;
 /**
  * Capitalizes the first letter of a string
  *
@@ -18,6 +15,6 @@ exports.capitalize = capitalize;
  * - Returns empty string if input is empty
  * - Commonly used for generating type names and class names
  */
-function capitalize(str) {
+export function capitalize(str) {
     return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
 }

package/dist/shared/utils/compose.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Functional composition utilities for cleaner code
+ *
+ * @module compose
+ */
+/**
+ * Pipes a value through a series of functions from left to right
+ *
+ * @template T - Initial value type
+ * @param value - The initial value
+ * @param fns - Functions to apply in sequence
+ * @returns The final transformed value
+ *
+ * @example
+ * const result = pipe(
+ *   "hello",
+ *   str => str.toUpperCase(),
+ *   str => str + "!",
+ *   str => str.repeat(2)
+ * ) // "HELLO!HELLO!"
+ */
+export declare function pipe<T>(value: T, ...fns: Array<(arg: any) => any>): any
+/**
+ * Composes functions from right to left
+ *
+ * @param fns - Functions to compose
+ * @returns A new function that applies all functions in sequence
+ *
+ * @example
+ * const transform = compose(
+ *   str => str.repeat(2),
+ *   str => str + "!",
+ *   str => str.toUpperCase()
+ * )
+ * transform("hello") // "HELLO!HELLO!"
+ */
+export declare function compose<T>(...fns: Array<(arg: any) => any>): (arg: T) => any
+/**
+ * Maybe monad for handling nullable values
+ *
+ * @template T - The wrapped value type
+ */
+export declare class Maybe<T> {
+  private value
+  private constructor()
+  /**
+   * Creates a Maybe from a value
+   */
+  static of<T>(value: T | null | undefined): Maybe<T>
+  /**
+   * Creates a Maybe with no value
+   */
+  static none<T>(): Maybe<T>
+  /**
+   * Maps a function over the Maybe value
+   */
+  map<U>(fn: (value: T) => U): Maybe<U>
+  /**
+   * Flat maps a function that returns a Maybe
+   */
+  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>
+  /**
+   * Returns the value or a default
+   */
+  getOrElse(defaultValue: T): T
+  /**
+   * Returns the value or null
+   */
+  getOrNull(): T | null
+  /**
+   * Checks if the Maybe has a value
+   */
+  isSome(): boolean
+  /**
+   * Checks if the Maybe has no value
+   */
+  isNone(): boolean
+}
+/**
+ * Helper function to create a Maybe
+ */
+export declare const maybe: <T>(value: T | null | undefined) => Maybe<T>
+/**
+ * Applies a function only if the condition is true
+ *
+ * @param condition - The condition to check
+ * @param fn - The function to apply
+ * @returns A function that conditionally applies the transformation
+ */
+export declare function when<T>(condition: boolean, fn: (value: T) => T): (value: T) => T
+/**
+ * Applies a function only if the predicate returns true
+ *
+ * @param predicate - The predicate function
+ * @param fn - The function to apply
+ * @returns A function that conditionally applies the transformation
+ */
+export declare function whenPredicate<T>(
+  predicate: (value: T) => boolean,
+  fn: (value: T) => T,
+): (value: T) => T