ts-prorm-orm 1.1.0 → 1.2.1

package/dist/decorators/orm-decorators.d.ts

@@ -0,0 +1,274 @@
+/**
+ * ORM Decorators Registry
+ *
+ * Central registry of all decorator names used in the ORM.
+ * Useful for documentation, tooling, and reflection-based operations.
+ *
+ * Usage:
+ *
+ *   import { ORMDecorators } from './orm-decorators';
+ *
+ *   // Access decorator names
+ *   console.log(ORMDecorators.Table); // 'Table'
+ *   console.log(ORMDecorators.Column); // 'Column'
+ */
+/**
+ * All ORM decorator names organized by category.
+ *
+ * This constant provides a centralized registry of decorator names
+ * used throughout the ORM for documentation, tooling, and reflection.
+ */
+export declare const ORMDecorators: {
+    /** Model/table decorator */
+    readonly Table: "Table";
+    /** Schema/database schema decorator */
+    readonly Schema: "Schema";
+    /** Column/property decorator */
+    readonly Column: "Column";
+    /** Primary key decorator */
+    readonly PrimaryKey: "PrimaryKey";
+    /** Check constraint decorator */
+    readonly Check: "Check";
+    /** Unique constraint decorator */
+    readonly Unique: "Unique";
+    /** Default value decorator */
+    readonly Default: "Default";
+    /** Foreign key decorator */
+    readonly ForeignKey: "ForeignKey";
+    /** Index decorator */
+    readonly Index: "Index";
+    /** Partition decorator */
+    readonly Partition: "Partition";
+    /** BelongsTo association decorator */
+    readonly BelongsTo: "BelongsTo";
+    /** HasOne association decorator */
+    readonly HasOne: "HasOne";
+    /** HasMany association decorator */
+    readonly HasMany: "HasMany";
+    /** Many-to-many (junction) association decorator */
+    readonly BelongsToMany: "BelongsToMany";
+    /** Before create hook */
+    readonly BeforeCreate: "BeforeCreate";
+    /** Before bulk create hook */
+    readonly BeforeBulkCreate: "BeforeBulkCreate";
+    /** Before update hook */
+    readonly BeforeUpdate: "BeforeUpdate";
+    /** Before bulk update hook */
+    readonly BeforeBulkUpdate: "BeforeBulkUpdate";
+    /** Before delete hook */
+    readonly BeforeDelete: "BeforeDelete";
+    /** Before bulk delete hook */
+    readonly BeforeBulkDelete: "BeforeBulkDelete";
+    /** Before find hook */
+    readonly BeforeFind: "BeforeFind";
+    /** Before find after expand options hook */
+    readonly BeforeFindAfterExpandOptions: "BeforeFindAfterExpandOptions";
+    /** Before find after distribution hook */
+    readonly BeforeFindAfterSetup: "BeforeFindAfterSetup";
+    /** Before init hook */
+    readonly BeforeInit: "BeforeInit";
+    /** Before connect hook */
+    readonly BeforeConnect: "BeforeConnect";
+    /** Before query hook */
+    readonly BeforeQuery: "BeforeQuery";
+    /** Before sync hook */
+    readonly BeforeSync: "BeforeSync";
+    /** After create hook */
+    readonly AfterCreate: "AfterCreate";
+    /** After bulk create hook */
+    readonly AfterBulkCreate: "AfterBulkCreate";
+    /** After update hook */
+    readonly AfterUpdate: "AfterUpdate";
+    /** After bulk update hook */
+    readonly AfterBulkUpdate: "AfterBulkUpdate";
+    /** After delete hook */
+    readonly AfterDelete: "AfterDelete";
+    /** After bulk delete hook */
+    readonly AfterBulkDelete: "AfterBulkDelete";
+    /** After find hook */
+    readonly AfterFind: "AfterFind";
+    /** After init hook */
+    readonly AfterInit: "AfterInit";
+    /** After connect hook */
+    readonly AfterConnect: "AfterConnect";
+    /** After query hook */
+    readonly AfterQuery: "AfterQuery";
+    /** After sync hook */
+    readonly AfterSync: "AfterSync";
+    /** Virtual/computed column decorator */
+    readonly Virtual: "Virtual";
+    /** Generated column decorator */
+    readonly Generated: "Generated";
+    /** Identity/auto-increment decorator */
+    readonly Identity: "Identity";
+    /** Default scope decorator */
+    readonly DefaultScope: "DefaultScope";
+    /** Named scopes decorator */
+    readonly Scopes: "Scopes";
+    /** Scope decorator (single) */
+    readonly Scope: "Scope";
+    /** Paranoid (soft delete) decorator */
+    readonly Paranoid: "Paranoid";
+    /** CreatedAt timestamp decorator */
+    readonly CreatedAt: "CreatedAt";
+    /** UpdatedAt timestamp decorator */
+    readonly UpdatedAt: "UpdatedAt";
+    /** DeletedAt timestamp decorator */
+    readonly DeletedAt: "DeletedAt";
+    /** Version (optimistic locking) decorator */
+    readonly Version: "Version";
+    /** Trigger decorator */
+    readonly Trigger: "Trigger";
+    /** Stored procedure decorator */
+    readonly Procedure: "Procedure";
+    /** SQL function decorator */
+    readonly Function: "Function";
+    /** Function: 'Function' (alias for clarity) */
+    readonly SqlFunction: "SqlFunction";
+    /** Sequence decorator */
+    readonly Sequence: "Sequence";
+    /** Extension decorator */
+    readonly Extension: "Extension";
+    /** Row-level security decorator */
+    readonly RowLevelSecurity: "RowLevelSecurity";
+    /** Policy decorator */
+    readonly Policy: "Policy";
+    /** Table inheritance decorator */
+    readonly Inheritance: "Inheritance";
+    /** Partition decorator (PostgreSQL specific) */
+    readonly PartitionPostgres: "Partition";
+    /** Event decorator (MySQL/MariaDB) */
+    readonly Event: "Event";
+    /** Stored routine decorator */
+    readonly Routine: "Routine";
+    /** Foreign table decorator (SQLite FDW) */
+    readonly ForeignTable: "ForeignTable";
+    /** View decorator */
+    readonly View: "View";
+    /** Foreign key checks setting decorator */
+    readonly ForeignKeyChecks: "ForeignKeyChecks";
+    /** Database setting decorator */
+    readonly DatabaseSetting: "DatabaseSetting";
+    /** Comment decorator */
+    readonly Comment: "Comment";
+    /** Secure field decorator */
+    readonly Secure: "Secure";
+    /** Secure field decorator (alias) */
+    readonly SecureField: "SecureField";
+    /** Permission decorator */
+    readonly Permission: "Permission";
+    /** Can view decorator */
+    readonly CanView: "CanView";
+    /** Cannot view decorator */
+    readonly CannotView: "CannotView";
+    /** Can write decorator */
+    readonly CanWrite: "CanWrite";
+    /** Cannot write decorator */
+    readonly CannotWrite: "CannotWrite";
+    /** Audit decorator */
+    readonly Audit: "Audit";
+    /** AuditChange decorator */
+    readonly AuditChange: "AuditChange";
+    /** AuditLog decorator */
+    readonly AuditLog: "AuditLog";
+    /** Validate decorator */
+    readonly Validate: "Validate";
+    /** Is decorator (validation rule) */
+    readonly Is: "Is";
+    /** IsAlpha decorator */
+    readonly IsAlpha: "IsAlpha";
+    /** IsAlphanumeric decorator */
+    readonly IsAlphanumeric: "IsAlphanumeric";
+    /** IsNumeric decorator */
+    readonly IsNumeric: "IsNumeric";
+    /** IsEmail decorator */
+    readonly IsEmail: "IsEmail";
+    /** IsURL decorator */
+    readonly IsURL: "IsURL";
+    /** IsIP decorator */
+    readonly IsIP: "IsIP";
+    /** IsDate decorator */
+    readonly IsDate: "IsDate";
+    /** IsInt decorator */
+    readonly IsInt: "IsInt";
+    /** IsFloat decorator */
+    readonly IsFloat: "IsFloat";
+    /** IsBoolean decorator */
+    readonly IsBoolean: "IsBoolean";
+    /** IsUUID decorator */
+    readonly IsUUID: "IsUUID";
+    /** IsJSON decorator */
+    readonly IsJSON: "IsJSON";
+    /** IsNull decorator */
+    readonly IsNull: "IsNull";
+    /** NotEmpty decorator */
+    readonly NotEmpty: "NotEmpty";
+    /** Len decorator (length validation) */
+    readonly Len: "Len";
+    /** Min decorator */
+    readonly Min: "Min";
+    /** Max decorator */
+    readonly Max: "Max";
+    /** IsIn decorator */
+    readonly IsIn: "IsIn";
+    /** NotIn decorator */
+    readonly NotIn: "NotIn";
+    /** Regexp decorator */
+    readonly Regexp: "Regexp";
+    /** NotRegexp decorator */
+    readonly NotRegexp: "NotRegexp";
+    /** IsCreditCard decorator */
+    readonly IsCreditCard: "IsCreditCard";
+    /** IsISBN decorator */
+    readonly IsISBN: "IsISBN";
+    /** IsMobilePhone decorator */
+    readonly IsMobilePhone: "IsMobilePhone";
+    /** IsPostalCode decorator */
+    readonly IsPostalCode: "IsPostalCode";
+    /** IsCurrency decorator */
+    readonly IsCurrency: "IsCurrency";
+    /** IsOctal decorator */
+    readonly IsOctal: "IsOctal";
+    /** IsDivisibleBy decorator */
+    readonly IsDivisibleBy: "IsDivisibleBy";
+    /** Index (alias for backward compatibility) */
+    readonly IndexAlt: "Index";
+    /** Raw decorator for raw SQL */
+    readonly Raw: "Raw";
+};
+/**
+ * Type of the ORMDecorators constant - all decorator names as a union type
+ */
+export type ORMDecoratorName = (typeof ORMDecorators)[keyof typeof ORMDecorators];
+/**
+ * Get all decorator names as an array
+ */
+export declare const ALL_DECORATORS: ("Default" | "Version" | "AuditLog" | "SqlFunction" | "Procedure" | "Column" | "Table" | "PrimaryKey" | "Unique" | "ForeignKey" | "Schema" | "Check" | "Index" | "Partition" | "BelongsTo" | "HasOne" | "HasMany" | "BelongsToMany" | "BeforeCreate" | "BeforeBulkCreate" | "BeforeUpdate" | "BeforeBulkUpdate" | "BeforeDelete" | "BeforeBulkDelete" | "BeforeFind" | "BeforeFindAfterExpandOptions" | "BeforeFindAfterSetup" | "BeforeInit" | "BeforeConnect" | "BeforeQuery" | "BeforeSync" | "AfterCreate" | "AfterBulkCreate" | "AfterUpdate" | "AfterBulkUpdate" | "AfterDelete" | "AfterBulkDelete" | "AfterFind" | "AfterInit" | "AfterConnect" | "AfterQuery" | "AfterSync" | "Virtual" | "Generated" | "Identity" | "DefaultScope" | "Scopes" | "Scope" | "Paranoid" | "CreatedAt" | "UpdatedAt" | "DeletedAt" | "Trigger" | "Function" | "Sequence" | "Extension" | "RowLevelSecurity" | "Policy" | "Inheritance" | "Event" | "Routine" | "ForeignTable" | "View" | "ForeignKeyChecks" | "DatabaseSetting" | "Comment" | "Secure" | "SecureField" | "Permission" | "CanView" | "CannotView" | "CanWrite" | "CannotWrite" | "Audit" | "AuditChange" | "Validate" | "Is" | "IsAlpha" | "IsAlphanumeric" | "IsNumeric" | "IsEmail" | "IsURL" | "IsIP" | "IsDate" | "IsInt" | "IsFloat" | "IsBoolean" | "IsUUID" | "IsJSON" | "IsNull" | "NotEmpty" | "Len" | "Min" | "Max" | "IsIn" | "NotIn" | "Regexp" | "NotRegexp" | "IsCreditCard" | "IsISBN" | "IsMobilePhone" | "IsPostalCode" | "IsCurrency" | "IsOctal" | "IsDivisibleBy" | "Raw")[];
+/**
+ * Get all model definition decorators
+ */
+export declare const MODEL_DECORATORS: readonly ["Table", "Schema", "Column", "PrimaryKey"];
+/**
+ * Get all constraint decorators
+ */
+export declare const CONSTRAINT_DECORATORS: readonly ["Check", "Unique", "Default", "ForeignKey", "Index", "Partition"];
+/**
+ * Get all association decorators
+ */
+export declare const ASSOCIATION_DECORATORS: readonly ["BelongsTo", "HasOne", "HasMany", "BelongsToMany"];
+/**
+ * Get all hook decorators (before and after)
+ */
+export declare const HOOK_DECORATORS: readonly ["BeforeCreate", "BeforeBulkCreate", "BeforeUpdate", "BeforeBulkUpdate", "BeforeDelete", "BeforeBulkDelete", "BeforeFind", "BeforeFindAfterExpandOptions", "BeforeFindAfterSetup", "BeforeInit", "BeforeConnect", "BeforeQuery", "BeforeSync", "AfterCreate", "AfterBulkCreate", "AfterUpdate", "AfterBulkUpdate", "AfterDelete", "AfterBulkDelete", "AfterFind", "AfterInit", "AfterConnect", "AfterQuery", "AfterSync"];
+/**
+ * Get all validation decorators
+ */
+export declare const VALIDATION_DECORATORS: readonly ["Validate", "Is", "IsAlpha", "IsAlphanumeric", "IsNumeric", "IsEmail", "IsURL", "IsIP", "IsDate", "IsInt", "IsFloat", "IsBoolean", "IsUUID", "IsJSON", "IsNull", "NotEmpty", "Len", "Min", "Max", "IsIn", "NotIn", "Regexp", "NotRegexp", "IsCreditCard", "IsISBN", "IsMobilePhone", "IsPostalCode", "IsCurrency", "IsOctal", "IsDivisibleBy"];
+/**
+ * Get all PostgreSQL-specific decorators
+ */
+export declare const POSTGRES_DECORATORS: readonly ["Trigger", "Procedure", "Function", "SqlFunction", "Sequence", "Extension", "RowLevelSecurity", "Policy", "Inheritance"];
+/**
+ * Get all database setting decorators
+ */
+export declare const SETTINGS_DECORATORS: readonly ["ForeignKeyChecks", "DatabaseSetting"];

package/dist/decorators/permissions.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Permission / access-control decorators for the ORM.
+ *
+ * These decorators let you annotate model classes and individual fields with
+ * access rules — which roles can read, write, or are completely blocked from
+ * a field or an entire model. At query time you call filterByPermissions()
+ * to strip out any fields the current user is not allowed to see.
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ * Quick Reference
+ * ──────────────────────────────────────────────────────────────────────────
+ *
+ *  @CanView('admin', 'manager')     — only these roles can read the field/model
+ *  @CannotView('guest')             — these roles are DENIED read access
+ *  @CanWrite('admin')               — only these roles can write the field
+ *  @CannotWrite('guest')            — these roles are DENIED write access
+ *  @Permission({ ... })             — full control with explicit allow/deny lists
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ * Example
+ * ──────────────────────────────────────────────────────────────────────────
+ *
+ *   // Field-level permissions (applied via static registration):
+ *   PermissionRegistry.addFieldRule(User, 'ssn',      { canView: ['admin'] });
+ *   PermissionRegistry.addFieldRule(User, 'salary',   { canView: ['admin', 'hr'] });
+ *   PermissionRegistry.addFieldRule(User, 'password', { canView: [] });  // nobody
+ *
+ *   // Class-level permission (applied via decorator):
+ *   @CanView('admin', 'manager')
+ *   class AuditLog extends Model { ... }
+ *
+ *   // At request time:
+ *   const currentRole = 'guest';
+ *   const user = await User.findOne({ where: { id: 1 } });
+ *   const safeUser = filterByPermissions(user, currentRole);
+ *   // safeUser.ssn === undefined, safeUser.salary === undefined
+ *
+ *   // Or get the allowed attribute list for a findAll() call:
+ *   const attrs = getAllowedAttributes(User, currentRole);
+ *   const users = await User.findAll({ attributes: attrs });
+ */
+export interface PermissionRule {
+    /**
+     * Roles that are explicitly ALLOWED to read this field/model.
+     * If this array is present (even empty), only roles in this list can read.
+     * A '*' entry means "any role".
+     */
+    canView?: string[];
+    /**
+     * Roles that are explicitly DENIED read access, regardless of canView.
+     */
+    cannotView?: string[];
+    /**
+     * Roles that are explicitly ALLOWED to write this field.
+     * If this array is present, only roles in this list can write.
+     */
+    canWrite?: string[];
+    /**
+     * Roles that are explicitly DENIED write access.
+     */
+    cannotWrite?: string[];
+}
+export interface PermissionOptions extends PermissionRule {
+    /**
+     * Human-readable description of the permission rule (for docs/tooling).
+     */
+    description?: string;
+}
+export declare const PermissionRegistry: {
+    /**
+     * Register or update a permission rule for a specific field on a model.
+     *
+     * @param target    - The model class constructor
+     * @param fieldName - The attribute/field name
+     * @param rule      - The access rule
+     */
+    addFieldRule(target: Function, fieldName: string, rule: PermissionRule): void;
+    /**
+     * Get the rule for a specific field (or undefined if none).
+     */
+    getFieldRule(target: Function, fieldName: string): PermissionRule | undefined;
+    /**
+     * Get all field rules registered on a model.
+     */
+    getAllFieldRules(target: Function): Map<string, PermissionRule>;
+    /**
+     * Register or update a model-level permission rule (applies to ALL fields).
+     */
+    addModelRule(target: Function, rule: PermissionRule): void;
+    /**
+     * Get the model-level rule (or undefined if none).
+     */
+    getModelRule(target: Function): PermissionRule | undefined;
+};
+/**
+ * Check whether a given role can VIEW a field on a model.
+ *
+ * Resolution order:
+ *   1. Field-level cannotView  → deny if role is listed
+ *   2. Field-level canView     → allow only if role is listed (or '*' present)
+ *   3. Model-level cannotView  → deny if role is listed
+ *   4. Model-level canView     → allow only if role is listed (or '*' present)
+ *   5. Default: allow
+ *
+ * @param ModelClass - The model constructor
+ * @param fieldName  - The attribute name to check
+ * @param role       - The current user's role
+ */
+export declare function canViewField(ModelClass: Function, fieldName: string, role: string): boolean;
+/**
+ * Check whether a given role can WRITE a field on a model.
+ */
+export declare function canWriteField(ModelClass: Function, fieldName: string, role: string): boolean;
+/**
+ * Return the list of field names on a model that `role` is allowed to VIEW.
+ *
+ * Useful for passing to `findAll({ attributes: ... })` to prevent loading
+ * restricted data at the database level.
+ *
+ * @param ModelClass      - The model constructor
+ * @param role            - The current user's role
+ * @param allAttributes   - The full list of attribute names. If omitted,
+ *                          the registry's field rules are used as the universe
+ *                          (only fields with explicit rules are considered).
+ */
+export declare function getAllowedAttributes(ModelClass: Function, role: string, allAttributes?: string[]): string[];
+/**
+ * Strip restricted fields from a plain object or model instance.
+ *
+ * Returns a new plain object with only the fields `role` is allowed to see.
+ * Does not mutate the original.
+ *
+ * @param instance   - A model instance or plain record object
+ * @param role       - The current user's role
+ * @param ModelClass - The model class (defaults to instance.constructor)
+ */
+export declare function filterByPermissions(instance: any, role: string, ModelClass?: Function): Record<string, any>;
+/**
+ * Strip restricted fields from a plain object for WRITE operations.
+ * Removes any fields the role is not allowed to write.
+ */
+export declare function filterWriteByPermissions(data: Record<string, any>, role: string, ModelClass: Function): Record<string, any>;
+/**
+ * Allow only the listed roles to VIEW the decorated class (all fields) or
+ * use PermissionRegistry.addFieldRule() for per-field control.
+ *
+ *   @CanView('admin', 'manager')
+ *   class AuditLog extends Model { ... }
+ */
+export declare function CanView(...roles: string[]): (target: Function) => void;
+/**
+ * Deny the listed roles from viewing the decorated class.
+ *
+ *   @CannotView('guest', 'public')
+ *   class SensitiveReport extends Model { ... }
+ */
+export declare function CannotView(...roles: string[]): (target: Function) => void;
+/**
+ * Allow only the listed roles to WRITE to the decorated class.
+ *
+ *   @CanWrite('admin')
+ *   class Settings extends Model { ... }
+ */
+export declare function CanWrite(...roles: string[]): (target: Function) => void;
+/**
+ * Deny the listed roles from writing to the decorated class.
+ */
+export declare function CannotWrite(...roles: string[]): (target: Function) => void;
+/**
+ * Full permission decorator — applies read and write rules at the model level.
+ *
+ *   @Permission({ canView: ['admin', 'manager'], canWrite: ['admin'] })
+ *   class Invoice extends Model { ... }
+ */
+export declare function Permission(options: PermissionOptions): (target: Function) => void;
+/**
+ * A higher-order helper that wraps a controller function and automatically
+ * applies permission filtering on the result.
+ *
+ * Example:
+ *
+ *   const getUser = withPermissions(User, async (id: number) => {
+ *     return User.findByPk(id);
+ *   });
+ *
+ *   const safeUser = await getUser(1, 'guest');
+ *   // safeUser has only the fields 'guest' is allowed to see
+ *
+ * @param ModelClass - The model class whose permissions to apply
+ * @param fn         - The async controller function (last arg must be role string)
+ */
+export declare function withPermissions<T extends (...args: any[]) => Promise<any>>(ModelClass: Function, fn: T): (...args: [...Parameters<T>, string]) => Promise<Record<string, any> | null>;

package/dist/decorators/procedure.d.ts

@@ -0,0 +1,168 @@
+/**
+ * TypeScript decorators for SQL Stored Procedures and SQL Functions.
+ *
+ * @Procedure  — annotate a class method (or standalone function wrapper) so
+ *               it is understood by the ORM as a stored procedure.
+ *               The ORM can generate the CREATE PROCEDURE SQL and register
+ *               a callable wrapper on your Prorm instance.
+ *
+ * @SqlFunction — like @Procedure but for database functions that RETURN a
+ *                value and can be called inside SELECT / WHERE clauses.
+ *
+ * Both decorators store metadata in a registry. Register the class with
+ * `prorm.registerProcedures(MyProcedures)` and `sync()` will issue the DDL;
+ * `ProcedureRegistry.getSQL(target, method)` returns it if you'd rather run it
+ * yourself, and `ProcedureRegistry.call(prorm, target, method, args)` invokes it.
+ *
+ * Scope note: the `body` option is SQL, and deliberately so. These decorators
+ * generate the CREATE PROCEDURE envelope - name, parameter list, language,
+ * volatility, schema qualification and dialect differences - but the routine's
+ * body is procedural SQL (PL/pgSQL, MySQL's compound statements, PL/SQL) with
+ * no ORM-level equivalent. Everything a query can express belongs in a model
+ * method instead; reach for a stored procedure only when you specifically need
+ * logic to live in the database.
+ *
+ * Example:
+ *
+ *   class UserProcedures {
+ *     @Procedure({
+ *       name: 'get_user_by_email',
+ *       params: [{ name: 'p_email', type: 'VARCHAR(255)', mode: 'IN' }],
+ *       dialect: 'mysql',
+ *       body: `BEGIN SELECT * FROM users WHERE email = p_email; END`,
+ *     })
+ *     getUserByEmail(email: string) {}
+ *
+ *     @SqlFunction({
+ *       name: 'full_name',
+ *       params: [
+ *         { name: 'first', type: 'TEXT' },
+ *         { name: 'last',  type: 'TEXT' },
+ *       ],
+ *       returns: 'TEXT',
+ *       dialect: 'postgres',
+ *       body: `SELECT first || ' ' || last`,
+ *       language: 'SQL',
+ *     })
+ *     fullName(first: string, last: string): string { return ''; }
+ *   }
+ *
+ *   // Generate and run the DDL
+ *   const sql = ProcedureRegistry.getSQL(UserProcedures, 'getUserByEmail');
+ *   await prorm.query(sql);
+ *
+ *   // Or use the auto-call helper
+ *   const rows = await ProcedureRegistry.call(prorm, UserProcedures, 'getUserByEmail', ['john@example.com']);
+ */
+import type { Prorm } from '../prorm';
+export type ProcedureParamMode = 'IN' | 'OUT' | 'INOUT';
+export interface ProcedureParam {
+    /** SQL parameter name */
+    name: string;
+    /** SQL type string, e.g. 'VARCHAR(255)', 'INTEGER', 'TEXT' */
+    type: string;
+    /** Parameter mode (default: IN) */
+    mode?: ProcedureParamMode;
+}
+export interface ProcedureOptions {
+    /**
+     * The name of the stored procedure in the database.
+     * Defaults to the method name if not provided.
+     */
+    name?: string;
+    /** Input/output parameters */
+    params?: ProcedureParam[];
+    /**
+     * The SQL body of the procedure (everything inside BEGIN...END or $$...$$).
+     * If omitted, the generated DDL will have an empty body placeholder.
+     */
+    body?: string;
+    /**
+     * Target dialect. Controls the DDL syntax that is generated.
+     * One of: 'mysql' | 'mariadb' | 'postgres' | 'sqlite'
+     * Defaults to 'mysql'.
+     */
+    dialect?: 'mysql' | 'mariadb' | 'postgres' | 'sqlite';
+    /** Optional schema prefix, e.g. 'public' */
+    schema?: string;
+    /**
+     * If true, generates CREATE OR REPLACE PROCEDURE (Postgres) or
+     * DROP PROCEDURE IF EXISTS + CREATE PROCEDURE (MySQL).
+     * Default: false.
+     */
+    replace?: boolean;
+}
+export interface SqlFunctionOptions extends Omit<ProcedureOptions, 'params'> {
+    /** Input parameters (functions never have OUT params) */
+    params?: Omit<ProcedureParam, 'mode'>[];
+    /**
+     * SQL return type, e.g. 'TEXT', 'INTEGER', 'TABLE(id INT, name TEXT)'.
+     * Required for functions.
+     */
+    returns: string;
+    /**
+     * Procedural language. Default: 'plpgsql' for postgres, 'SQL' for simple expressions.
+     */
+    language?: string;
+    /**
+     * Set DETERMINISTIC / IMMUTABLE / STABLE / VOLATILE hint.
+     * MySQL: 'DETERMINISTIC' | 'NOT DETERMINISTIC'
+     * Postgres: 'IMMUTABLE' | 'STABLE' | 'VOLATILE'
+     */
+    volatility?: string;
+}
+interface ProcedureMeta {
+    kind: 'procedure' | 'function';
+    methodKey: string;
+    options: ProcedureOptions | SqlFunctionOptions;
+}
+/**
+ * Mark a method as a SQL stored procedure.
+ *
+ * The decorated method is a no-op at runtime — use ProcedureRegistry.call()
+ * to execute the actual database procedure.
+ */
+export declare function Procedure(options?: ProcedureOptions): (target: any, propertyKey: string, _descriptor: PropertyDescriptor) => void;
+/**
+ * Mark a method as a SQL function (returns a value, usable in SELECT/WHERE).
+ *
+ * The decorated method is a no-op at runtime — use ProcedureRegistry.call()
+ * to execute the actual database function.
+ */
+export declare function SqlFunction(options: SqlFunctionOptions): (target: any, propertyKey: string, _descriptor: PropertyDescriptor) => void;
+export declare const ProcedureRegistry: {
+    /**
+     * Get all registered procedures/functions on a class.
+     */
+    getAll(target: Function): ProcedureMeta[];
+    /**
+     * Get a single procedure/function meta by method name.
+     */
+    get(target: Function, methodKey: string): ProcedureMeta | undefined;
+    /**
+     * Generate the CREATE PROCEDURE / CREATE FUNCTION SQL for a registered method.
+     *
+     * @param target    - The class constructor
+     * @param methodKey - The method name
+     * @param dialect   - Override the dialect stored in the decorator options
+     */
+    getSQL(target: Function, methodKey: string, dialect?: "mysql" | "mariadb" | "postgres" | "sqlite"): string;
+    /**
+     * Generate DDL for every procedure/function on a class and execute them.
+     *
+     * @param prorm - Prorm instance
+     * @param target    - The class constructor
+     * @param dialect   - Override dialect
+     */
+    createAll(prorm: Prorm, target: Function, dialect?: "mysql" | "mariadb" | "postgres" | "sqlite"): Promise<void>;
+    /**
+     * Call a stored procedure.
+     *
+     * @param prorm - Prorm instance
+     * @param target    - The class constructor that has the @Procedure decorator
+     * @param methodKey - The method name
+     * @param args      - Arguments to pass (positional, matched to params order)
+     */
+    call(prorm: Prorm, target: Function, methodKey: string, args?: any[]): Promise<any>;
+};
+export {};