@warlock.js/cascade 5.30.0 → 5.32.0

package/esm/drivers/sql/sql-types.d.mts

@@ -13,28 +13,38 @@
  * Contains the SQL string with placeholders and the corresponding parameter values.
  * This separation prevents SQL injection by ensuring values are properly escaped.
  */
-type SqlQueryResult = {
-  /** The SQL query string with parameter placeholders ($1, $2, etc. or ?) */readonly sql: string; /** The parameter values in order matching the placeholders */
+export type SqlQueryResult = {
+  /** The SQL query string with parameter placeholders ($1, $2, etc. or ?) */
+  readonly sql: string;
+  /** The parameter values in order matching the placeholders */
   readonly params: unknown[];
 };
 /**
  * Supported SQL JOIN types.
  */
-type SqlJoinType = "inner" | "left" | "right" | "full" | "cross";
+export type SqlJoinType = "inner" | "left" | "right" | "full" | "cross";
 /**
  * SQL JOIN clause definition.
  *
  * Represents a JOIN between two tables with its condition.
  */
-type SqlJoinClause = {
-  /** Type of JOIN operation */readonly type: SqlJoinType; /** Target table to join */
-  readonly table: string; /** Optional alias for the joined table */
-  readonly alias?: string; /** JOIN condition */
+export type SqlJoinClause = {
+  /** Type of JOIN operation */
+  readonly type: SqlJoinType;
+  /** Target table to join */
+  readonly table: string;
+  /** Optional alias for the joined table */
+  readonly alias?: string;
+  /** JOIN condition */
   readonly on: {
-    /** Field from the left (current) table */readonly left: string; /** Comparison operator (usually "=") */
-    readonly operator: string; /** Field from the right (joined) table */
+    /** Field from the left (current) table */
+    readonly left: string;
+    /** Comparison operator (usually "=") */
+    readonly operator: string;
+    /** Field from the right (joined) table */
     readonly right: string;
-  }; /** Additional ON conditions (for complex joins) */
+  };
+  /** Additional ON conditions (for complex joins) */
   readonly additionalConditions?: Array<{
     readonly left: string;
     readonly operator: string;
@@ -44,76 +54,110 @@ type SqlJoinClause = {
 /**
  * SQL ORDER BY clause definition.
  */
-type SqlOrderClause = {
-  /** Column to order by */readonly column: string; /** Sort direction */
-  readonly direction: "asc" | "desc"; /** Nulls position (PostgreSQL-specific) */
+export type SqlOrderClause = {
+  /** Column to order by */
+  readonly column: string;
+  /** Sort direction */
+  readonly direction: "asc" | "desc";
+  /** Nulls position (PostgreSQL-specific) */
   readonly nulls?: "first" | "last";
 };
 /**
  * SQL GROUP BY clause definition.
  */
-type SqlGroupClause = {
-  /** Columns to group by */readonly columns: string[];
+export type SqlGroupClause = {
+  /** Columns to group by */
+  readonly columns: string[];
 };
 /**
  * SQL HAVING clause condition.
  */
-type SqlHavingClause = {
-  /** Aggregate function (count, sum, avg, etc.) */readonly aggregate: string; /** Column the aggregate operates on */
-  readonly column: string; /** Comparison operator */
-  readonly operator: string; /** Value to compare against */
+export type SqlHavingClause = {
+  /** Aggregate function (count, sum, avg, etc.) */
+  readonly aggregate: string;
+  /** Column the aggregate operates on */
+  readonly column: string;
+  /** Comparison operator */
+  readonly operator: string;
+  /** Value to compare against */
   readonly value: unknown;
 };
 /**
  * SQL WHERE clause operation types.
  */
-type SqlWhereType = "where" | "orWhere" | "whereRaw" | "orWhereRaw" | "whereNot" | "orWhereNot" | "whereExists" | "whereNotExists";
+export type SqlWhereType = "where" | "orWhere" | "whereRaw" | "orWhereRaw" | "whereNot" | "orWhereNot" | "whereExists" | "whereNotExists";
 /**
  * SQL WHERE clause operation.
  *
  * Represents a single WHERE condition with its type, field, operator, and value.
  */
-type SqlWhereOperation = {
-  /** Type of WHERE clause (where, orWhere, whereRaw, etc.) */readonly type: SqlWhereType; /** Field name (for standard where clauses) */
-  readonly field?: string; /** Comparison operator */
-  readonly operator?: string; /** Value to compare against */
-  readonly value?: unknown; /** Raw SQL expression (for whereRaw clauses) */
-  readonly raw?: string; /** Parameter bindings for raw expressions */
-  readonly bindings?: unknown[]; /** Nested conditions (for grouped where clauses) */
+export type SqlWhereOperation = {
+  /** Type of WHERE clause (where, orWhere, whereRaw, etc.) */
+  readonly type: SqlWhereType;
+  /** Field name (for standard where clauses) */
+  readonly field?: string;
+  /** Comparison operator */
+  readonly operator?: string;
+  /** Value to compare against */
+  readonly value?: unknown;
+  /** Raw SQL expression (for whereRaw clauses) */
+  readonly raw?: string;
+  /** Parameter bindings for raw expressions */
+  readonly bindings?: unknown[];
+  /** Nested conditions (for grouped where clauses) */
   readonly nested?: SqlWhereOperation[];
 };
 /**
  * SQL SELECT clause definition.
  */
-type SqlSelectClause = {
-  /** Column name or expression */readonly expression: string; /** Optional alias for the column */
-  readonly alias?: string; /** Whether this is a raw expression */
+export type SqlSelectClause = {
+  /** Column name or expression */
+  readonly expression: string;
+  /** Optional alias for the column */
+  readonly alias?: string;
+  /** Whether this is a raw expression */
   readonly isRaw?: boolean;
 };
 /**
  * Configuration for building SQL queries.
  */
-type SqlQueryConfig = {
-  /** Target table name */readonly table: string; /** Table alias (optional) */
-  readonly alias?: string; /** SELECT columns (empty = SELECT *) */
-  readonly select: SqlSelectClause[]; /** JOIN clauses */
-  readonly joins: SqlJoinClause[]; /** WHERE conditions */
-  readonly where: SqlWhereOperation[]; /** GROUP BY columns */
-  readonly groupBy: string[]; /** HAVING conditions */
-  readonly having: SqlHavingClause[]; /** ORDER BY clauses */
-  readonly orderBy: SqlOrderClause[]; /** LIMIT value */
-  readonly limit?: number; /** OFFSET value */
-  readonly offset?: number; /** DISTINCT flag */
+export type SqlQueryConfig = {
+  /** Target table name */
+  readonly table: string;
+  /** Table alias (optional) */
+  readonly alias?: string;
+  /** SELECT columns (empty = SELECT *) */
+  readonly select: SqlSelectClause[];
+  /** JOIN clauses */
+  readonly joins: SqlJoinClause[];
+  /** WHERE conditions */
+  readonly where: SqlWhereOperation[];
+  /** GROUP BY columns */
+  readonly groupBy: string[];
+  /** HAVING conditions */
+  readonly having: SqlHavingClause[];
+  /** ORDER BY clauses */
+  readonly orderBy: SqlOrderClause[];
+  /** LIMIT value */
+  readonly limit?: number;
+  /** OFFSET value */
+  readonly offset?: number;
+  /** DISTINCT flag */
   readonly distinct?: boolean;
 };
 /**
  * SQL INSERT operation definition.
  */
-type SqlInsertOperation = {
-  /** Target table */readonly table: string; /** Column names */
-  readonly columns: string[]; /** Values to insert (array of arrays for multi-row insert) */
-  readonly values: unknown[][]; /** Whether to return the inserted rows */
-  readonly returning?: string[] | boolean; /** Conflict resolution (upsert) */
+export type SqlInsertOperation = {
+  /** Target table */
+  readonly table: string;
+  /** Column names */
+  readonly columns: string[];
+  /** Values to insert (array of arrays for multi-row insert) */
+  readonly values: unknown[][];
+  /** Whether to return the inserted rows */
+  readonly returning?: string[] | boolean;
+  /** Conflict resolution (upsert) */
   readonly onConflict?: {
     readonly columns: string[];
     readonly action: "update" | "nothing";
@@ -123,28 +167,38 @@ type SqlInsertOperation = {
 /**
  * SQL UPDATE operation definition.
  */
-type SqlUpdateOperation = {
-  /** Target table */readonly table: string; /** Columns to set with their values */
-  readonly set: Record<string, unknown>; /** Columns to increment */
-  readonly increment?: Record<string, number>; /** Columns to set to NULL */
-  readonly unset?: string[]; /** WHERE conditions */
-  readonly where: SqlWhereOperation[]; /** Whether to return updated rows */
-  readonly returning?: string[] | boolean; /** Maximum rows to update (some databases support LIMIT in UPDATE) */
+export type SqlUpdateOperation = {
+  /** Target table */
+  readonly table: string;
+  /** Columns to set with their values */
+  readonly set: Record<string, unknown>;
+  /** Columns to increment */
+  readonly increment?: Record<string, number>;
+  /** Columns to set to NULL */
+  readonly unset?: string[];
+  /** WHERE conditions */
+  readonly where: SqlWhereOperation[];
+  /** Whether to return updated rows */
+  readonly returning?: string[] | boolean;
+  /** Maximum rows to update (some databases support LIMIT in UPDATE) */
   readonly limit?: number;
 };
 /**
  * SQL DELETE operation definition.
  */
-type SqlDeleteOperation = {
-  /** Target table */readonly table: string; /** WHERE conditions */
-  readonly where: SqlWhereOperation[]; /** Whether to return deleted rows */
-  readonly returning?: string[] | boolean; /** Maximum rows to delete */
+export type SqlDeleteOperation = {
+  /** Target table */
+  readonly table: string;
+  /** WHERE conditions */
+  readonly where: SqlWhereOperation[];
+  /** Whether to return deleted rows */
+  readonly returning?: string[] | boolean;
+  /** Maximum rows to delete */
   readonly limit?: number;
 };
 /**
  * Aggregate function types supported in SQL.
  */
-type SqlAggregateFunction = "count" | "sum" | "avg" | "min" | "max" | "array_agg" | "string_agg" | "jsonb_agg";
+export type SqlAggregateFunction = "count" | "sum" | "avg" | "min" | "max" | "array_agg" | "string_agg" | "jsonb_agg";
 //#endregion
-export { SqlAggregateFunction, SqlDeleteOperation, SqlGroupClause, SqlHavingClause, SqlInsertOperation, SqlJoinClause, SqlJoinType, SqlOrderClause, SqlQueryConfig, SqlQueryResult, SqlSelectClause, SqlUpdateOperation, SqlWhereOperation, SqlWhereType };
 //# sourceMappingURL=sql-types.d.mts.map

package/esm/drivers/sql/sql-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-types.d.mts","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/sql/sql-types.ts"],"mappings":";;AAeA;;;;AAIiB;AAMjB;;;;AAAuB;AAOvB;;;KAjBY,cAAA;EAmBD,oFAjBA,GAAA,UAmBA;EAAA,SAjBA,MAAM;AAAA;;;;KAML,WAAA;;;;;;KAOA,aAAA;EA2BA,sCAzBD,IAAA,EAAM,WAAA;WAEN,KAAA,UAyBA;EAAA,SAvBA,KAAA,WA2BA;EAAA,SAzBA,EAAA;IAyBK,mDAvBH,IAAA,UA6Ba;IAAA,SA3Bb,QAAA,UA6BK;IAAA,SA3BL,KAAA;EAAA,GAiCc;EAAA,SA9BhB,oBAAA,GAAuB,KAAK;IAAA,SAC1B,IAAA;IAAA,SACA,QAAA;IAAA,SACA,KAAA;EAAA;AAAA;;AAmCG;AAMhB;KAlCY,cAAA;oCAED,MAAA,UAgCa;EAAA,SA9Bb,SAAA,kBA6CkB;EAAA,SA3ClB,KAAA;AAAA;;;;KAMC,cAAA;EA6CD,mCA3CA,OAAO;AAAA;;;;KAMN,eAAA;EAiDA,0DA/CD,SAAA;WAEA,MAAA,UA+CA;EAAA,SA7CA,QAAA,UAiDA;EAAA,SA/CA,KAAA;AAAA;AAqDX;;;AAAA,KA/CY,YAAA;;;;;;KAeA,iBAAA;EAkCD,qEAhCA,IAAA,EAAM,YAAA,EAoCN;EAAA,SAlCA,KAAA,WAoCA;EAAA,SAlCA,QAAA,WAoCA;EAAA,SAlCA,KAAA,YAoCA;EAAA,SAlCA,GAAA,WAoCQ;EAAA,SAlCR,QAAA,cAoCS;EAAA,SAlCT,MAAA,GAAS,iBAAiB;AAAA;;;AAwClB;KAlCP,eAAA;EAwCkB,yCAtCnB,UAAA,UAsCmB;EAAA,SApCnB,KAAA,WAwCA;EAAA,SAtCA,KAAA;AAAA;;;;KAMC,cAAA;EAyCc,iCAvCf,KAAA,UA8CC;EAAA,SA5CD,KAAA;WAEA,MAAA,EAAQ,eAAA,IAgDI;EAAA,SA9CZ,KAAA,EAAO,aAAA,IAkDiB;EAAA,SAhDxB,KAAA,EAAO,iBAAA,IAwCP;EAAA,SAtCA,OAAA,YAwCK;EAAA,SAtCL,MAAA,EAAQ,eAAA,IAwCI;EAAA,SAtCZ,OAAA,EAAS,cAAA,IA0CT;EAAA,SAxCA,KAAA,WA0CA;EAAA,SAxCA,MAAA,WA0CK;EAAA,SAxCL,QAAA;AAAA;;;;KAMC,kBAAA;EA4CD,4BA1CA,KAAA,UA4CA;EAAA,SA1CA,OAAA,YA4CK;EAAA,SA1CL,MAAA,eAgDC;EAAA,SA9CD,SAAA;WAEA,UAAA;IAAA,SACE,OAAA;IAAA,SACA,MAAA;IAAA,SACA,aAAA;EAAA;AAAA;;;;KAOD,kBAAA;8BAED,KAAA;WAEA,GAAA,EAAK,MAAA;WAEL,SAAA,GAAY,MAAA;WAEZ,KAAA;WAEA,KAAA,EAAO,iBAAA;WAEP,SAAA;WAEA,KAAA;AAAA;;;;KAMC,kBAAA;8BAED,KAAA;WAEA,KAAA,EAAO,iBAAiB;WAExB,SAAA;WAEA,KAAA;AAAA;;;;KAMC,oBAAA"}
+{"version":3,"file":"sql-types.d.mts","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/sql/sql-types.ts"],"mappings":";;;;;;;;;;;;;;;YAeY;;WAED;;WAEA;;;;;YAMC;;;;;;YAOA;;WAED,MAAM;;WAEN;;WAEA;;WAEA;;aAEE;;aAEA;;aAEA;;;WAGF,uBAAuB;aACrB;aACA;aACA;;;;;;YAOD;;WAED;;WAEA;;WAEA;;;;;YAMC;;WAED;;;;;YAMC;;WAED;;WAEA;;WAEA;;WAEA;;;;;YAMC;;;;;;YAeA;;WAED,MAAM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,SAAS;;;;;YAMR;;WAED;;WAEA;;WAEA;;;;;YAMC;;WAED;;WAEA;;WAEA,QAAQ;;WAER,OAAO;;WAEP,OAAO;;WAEP;;WAEA,QAAQ;;WAER,SAAS;;WAET;;WAEA;;WAEA;;;;;YAMC;;WAED;;WAEA;;WAEA;;WAEA;;WAEA;aACE;aACA;aACA;;;;;;YAOD;;WAED;;WAEA,KAAK;;WAEL,YAAY;;WAEZ;;WAEA,OAAO;;WAEP;;WAEA;;;;;YAMC;;WAED;;WAEA,OAAO;;WAEP;;WAEA;;;;;YAMC"}

package/esm/errors/missing-data-source.error.d.mts

@@ -7,7 +7,7 @@
  * - Trying to get the default data source before any have been registered
  * - Context override references an unregistered data source name
  */
-declare class MissingDataSourceError extends Error {
+export declare class MissingDataSourceError extends Error {
   /**
    * The name of the data source that was not found (if applicable).
    */
@@ -21,5 +21,4 @@ declare class MissingDataSourceError extends Error {
   constructor(message: string, dataSourceName?: string);
 }
 //#endregion
-export { MissingDataSourceError };
 //# sourceMappingURL=missing-data-source.error.d.mts.map

package/esm/errors/missing-data-source.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"missing-data-source.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/missing-data-source.error.ts"],"mappings":";;AAQA;;;;;;;cAAa,sBAAA,SAA+B,KAAK;EAYX;;AAAuB;EAAvB,SARpB,cAAA;;;;;;;cAQG,OAAA,UAAiB,cAAA;AAAA"}
+{"version":3,"file":"missing-data-source.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/missing-data-source.error.ts"],"mappings":";;;;;;;;;qBAQa,+BAA+B;;;;WAI1B;;;;;;;EAQhB,YAAmB,iBAAiB"}

package/esm/errors/transaction-rollback.error.d.mts

@@ -6,7 +6,7 @@
  * an application error. It's caught by the transaction wrapper to perform
  * cleanup and then re-thrown.
  */
-declare class TransactionRollbackError extends Error {
+export declare class TransactionRollbackError extends Error {
   /**
    * The reason for the rollback (if provided).
    */
@@ -19,5 +19,4 @@ declare class TransactionRollbackError extends Error {
   constructor(reason?: string);
 }
 //#endregion
-export { TransactionRollbackError };
 //# sourceMappingURL=transaction-rollback.error.d.mts.map

package/esm/errors/transaction-rollback.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction-rollback.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/transaction-rollback.error.ts"],"mappings":";;AAOA;;;;;;cAAa,wBAAA,SAAiC,KAAK;EAW9B;;AAAe;EAAf,SAPH,MAAA;;;;;;cAOG,MAAA;AAAA"}
+{"version":3,"file":"transaction-rollback.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/transaction-rollback.error.ts"],"mappings":";;;;;;;;qBAOa,iCAAiC;;;;WAI5B;;;;;;EAOhB,YAAmB"}

package/esm/errors/undefined-where-value.error.d.mts

@@ -15,7 +15,7 @@
  * valid, intentional query. To skip the query entirely when there's no
  * value, guard the call site instead of calling `where()`.
  */
-declare class UndefinedWhereValueError extends Error {
+export declare class UndefinedWhereValueError extends Error {
   /**
    * The field whose value was `undefined`.
    */
@@ -28,5 +28,4 @@ declare class UndefinedWhereValueError extends Error {
   constructor(field: string);
 }
 //#endregion
-export { UndefinedWhereValueError };
 //# sourceMappingURL=undefined-where-value.error.d.mts.map

package/esm/errors/undefined-where-value.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"undefined-where-value.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/undefined-where-value.error.ts"],"mappings":";;AAgBA;;;;;;;;;AAWkC;;;;;;cAXrB,wBAAA,SAAiC,KAAK;;;;WAIjC,KAAA;;;;;;cAOG,KAAA;AAAA"}
+{"version":3,"file":"undefined-where-value.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/undefined-where-value.error.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAgBa,iCAAiC;;;;WAI5B;;;;;;EAOhB,YAAmB"}

package/esm/errors/unsafe-filter.error.d.mts

@@ -10,7 +10,7 @@
  * - `whereIn` / `whereNull` / `whereBetween` / … for specific operators
  * - `whereRaw({ ... })` (object form) for intentional raw driver filters
  */
-declare class UnsafeFilterError extends Error {
+export declare class UnsafeFilterError extends Error {
   /**
    * The field whose value contained the rejected operator key (if applicable).
    */
@@ -29,5 +29,4 @@ declare class UnsafeFilterError extends Error {
   constructor(message: string, field?: string, operatorKey?: string);
 }
 //#endregion
-export { UnsafeFilterError };
 //# sourceMappingURL=unsafe-filter.error.d.mts.map

package/esm/errors/unsafe-filter.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unsafe-filter.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsafe-filter.error.ts"],"mappings":";;AAWA;;;;;;;;;;cAAa,iBAAA,SAA0B,KAAK;EAkB8B;AAAA;;EAAA,SAdxD,KAAA;;;;WAKA,WAAA;;;;;;;;cASG,OAAA,UAAiB,KAAA,WAAgB,WAAA;AAAA"}
+{"version":3,"file":"unsafe-filter.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsafe-filter.error.ts"],"mappings":";;;;;;;;;;;;qBAWa,0BAA0B;;;;WAIrB;;;;WAKA;;;;;;;;EAShB,YAAmB,iBAAiB,gBAAgB"}

package/esm/errors/unsafe-raw-expression.error.d.mts

@@ -10,7 +10,7 @@
  *
  * Use the object form instead, e.g. `whereRaw({ $expr: { $gt: ["$stock", "$reserved"] } })`.
  */
-declare class UnsafeRawExpressionError extends Error {
+export declare class UnsafeRawExpressionError extends Error {
   /**
    * Creates a new UnsafeRawExpressionError.
    *
@@ -19,5 +19,4 @@ declare class UnsafeRawExpressionError extends Error {
   constructor(message: string);
 }
 //#endregion
-export { UnsafeRawExpressionError };
 //# sourceMappingURL=unsafe-raw-expression.error.d.mts.map

package/esm/errors/unsafe-raw-expression.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unsafe-raw-expression.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsafe-raw-expression.error.ts"],"mappings":";;AAWA;;;;;;;;AAMoC;;cANvB,wBAAA,SAAiC,KAAK;;;;;;cAM9B,OAAA;AAAA"}
+{"version":3,"file":"unsafe-raw-expression.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsafe-raw-expression.error.ts"],"mappings":";;;;;;;;;;;;qBAWa,iCAAiC;;;;;;EAM5C,YAAmB"}

package/esm/errors/unsupported-lean-operation.error.d.mts

@@ -8,7 +8,7 @@
  * model's `hidden` fields) by the Model layer, so lean mode refuses them rather
  * than returning a half-loaded or unfiltered result.
  */
-declare class UnsupportedLeanOperationError extends Error {
+export declare class UnsupportedLeanOperationError extends Error {
   /**
    * The rejected builder operation (e.g. `"with"`, `"joinWith"`).
    */
@@ -21,5 +21,4 @@ declare class UnsupportedLeanOperationError extends Error {
   constructor(operation: string);
 }
 //#endregion
-export { UnsupportedLeanOperationError };
 //# sourceMappingURL=unsupported-lean-operation.error.d.mts.map

package/esm/errors/unsupported-lean-operation.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unsupported-lean-operation.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-lean-operation.error.ts"],"mappings":";;AASA;;;;;;;;cAAa,6BAAA,SAAsC,KAAK;EAWlB;;;EAAA,SAPpB,SAAA;;;;;;cAOG,SAAA;AAAA"}
+{"version":3,"file":"unsupported-lean-operation.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-lean-operation.error.ts"],"mappings":";;;;;;;;;;qBASa,sCAAsC;;;;WAIjC;;;;;;EAOhB,YAAmB"}

package/esm/errors/unsupported-lock-for-update.error.d.mts

@@ -3,9 +3,8 @@
  * Error thrown when `lockForUpdate()` is requested on MongoDB, whose document
  * model has no row-level `SELECT ... FOR UPDATE` equivalent.
  */
-declare class UnsupportedLockForUpdateError extends Error {
+export declare class UnsupportedLockForUpdateError extends Error {
   constructor();
 }
 //#endregion
-export { UnsupportedLockForUpdateError };
 //# sourceMappingURL=unsupported-lock-for-update.error.d.mts.map

package/esm/errors/unsupported-lock-for-update.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unsupported-lock-for-update.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-lock-for-update.error.ts"],"mappings":";;AAIA;;;cAAa,6BAAA,SAAsC,KAAK;EAAL,WAAA;AAAA"}
+{"version":3,"file":"unsupported-lock-for-update.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-lock-for-update.error.ts"],"mappings":";;;;;qBAIa,sCAAsC;EACjD"}

package/esm/errors/unsupported-query-operation.error.d.mts

@@ -7,7 +7,7 @@
  * Builders throw this instead of silently dropping the stage, so a caller
  * never receives rows shaped differently from what the query asked for.
  */
-declare class UnsupportedQueryOperationError extends Error {
+export declare class UnsupportedQueryOperationError extends Error {
   /**
    * The operation that was rejected (e.g. `"unwind"`, `"addFields"`).
    */
@@ -26,5 +26,4 @@ declare class UnsupportedQueryOperationError extends Error {
   constructor(operation: string, driver: string, hint?: string);
 }
 //#endregion
-export { UnsupportedQueryOperationError };
 //# sourceMappingURL=unsupported-query-operation.error.d.mts.map

package/esm/errors/unsupported-query-operation.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unsupported-query-operation.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-query-operation.error.ts"],"mappings":";;AAQA;;;;;;;cAAa,8BAAA,SAAuC,KAAK;EAkBpC;;;EAAA,SAdH,SAAA;EAcmD;;;EAAA,SATnD,MAAA;;;;;;;;cASG,SAAA,UAAmB,MAAA,UAAgB,IAAA;AAAA"}
+{"version":3,"file":"unsupported-query-operation.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-query-operation.error.ts"],"mappings":";;;;;;;;;qBAQa,uCAAuC;;;;WAIlC;;;;WAKA;;;;;;;;EAShB,YAAmB,mBAAmB,gBAAgB"}

package/esm/errors/unsupported-query-operation.error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unsupported-query-operation.error.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-query-operation.error.ts"],"sourcesContent":["/**\n * Error thrown when a query builder is asked for a read operation its driver\n * cannot express — e.g. a MongoDB-only aggregation stage such as `unwind()` or\n * `addFields()` on a SQL driver.\n *\n * Builders throw this instead of silently dropping the stage, so a caller\n * never receives rows shaped differently from what the query asked for.\n */\nexport class UnsupportedQueryOperationError extends Error {\n  /**\n   * The operation that was rejected (e.g. `\"unwind\"`, `\"addFields\"`).\n   */\n  public readonly operation: string;\n\n  /**\n   * The driver that rejected it (e.g. `\"postgres\"`).\n   */\n  public readonly driver: string;\n\n  /**\n   * Creates a new UnsupportedQueryOperationError.\n   *\n   * @param operation - The rejected operation\n   * @param driver - The driver name\n   * @param hint - Optional guidance appended to the message\n   */\n  public constructor(operation: string, driver: string, hint?: string) {\n    super(`The ${driver} driver does not support ${operation}() in queries.` + (hint ? ` ${hint}` : \"\"));\n    this.name = \"UnsupportedQueryOperationError\";\n    this.operation = operation;\n    this.driver = driver;\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, UnsupportedQueryOperationError);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AAQA,IAAa,iCAAb,MAAa,uCAAuC,MAAM;;;;CAIxD,AAAgB;;;;CAKhB,AAAgB;;;;;;;;CAShB,AAAO,YAAY,WAAmB,QAAgB,MAAe;EACnE,MAAM,OAAO,OAAO,2BAA2B,UAAU,mBAAmB,OAAO,IAAI,SAAS,GAAG;EACnG,KAAK,OAAO;EACZ,KAAK,YAAY;EACjB,KAAK,SAAS;EAEd,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,8BAA8B;CAEhE;AACF"}
+{"version":3,"file":"unsupported-query-operation.error.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-query-operation.error.ts"],"sourcesContent":["/**\n * Error thrown when a query builder is asked for a read operation its driver\n * cannot express — e.g. a MongoDB-only aggregation stage such as `unwind()` or\n * `addFields()` on a SQL driver.\n *\n * Builders throw this instead of silently dropping the stage, so a caller\n * never receives rows shaped differently from what the query asked for.\n */\nexport class UnsupportedQueryOperationError extends Error {\n  /**\n   * The operation that was rejected (e.g. `\"unwind\"`, `\"addFields\"`).\n   */\n  public readonly operation: string;\n\n  /**\n   * The driver that rejected it (e.g. `\"postgres\"`).\n   */\n  public readonly driver: string;\n\n  /**\n   * Creates a new UnsupportedQueryOperationError.\n   *\n   * @param operation - The rejected operation\n   * @param driver - The driver name\n   * @param hint - Optional guidance appended to the message\n   */\n  public constructor(operation: string, driver: string, hint?: string) {\n    super(\n      `The ${driver} driver does not support ${operation}() in queries.` + (hint ? ` ${hint}` : \"\"),\n    );\n    this.name = \"UnsupportedQueryOperationError\";\n    this.operation = operation;\n    this.driver = driver;\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, UnsupportedQueryOperationError);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AAQA,IAAa,iCAAb,MAAa,uCAAuC,MAAM;;;;CAIxD,AAAgB;;;;CAKhB,AAAgB;;;;;;;;CAShB,AAAO,YAAY,WAAmB,QAAgB,MAAe;EACnE,MACE,OAAO,OAAO,2BAA2B,UAAU,mBAAmB,OAAO,IAAI,SAAS,GAC5F;EACA,KAAK,OAAO;EACZ,KAAK,YAAY;EACjB,KAAK,SAAS;EAEd,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,8BAA8B;CAEhE;AACF"}

package/esm/errors/unsupported-update-operation.error.d.mts

@@ -7,7 +7,7 @@
  * Drivers throw this instead of silently dropping the operation, so a caller
  * never believes a write happened that did not.
  */
-declare class UnsupportedUpdateOperationError extends Error {
+export declare class UnsupportedUpdateOperationError extends Error {
   /**
    * The operation that was rejected (e.g. `"pipeline update"`, `"$addToSet"`).
    */
@@ -26,5 +26,4 @@ declare class UnsupportedUpdateOperationError extends Error {
   constructor(operation: string, driver: string, hint?: string);
 }
 //#endregion
-export { UnsupportedUpdateOperationError };
 //# sourceMappingURL=unsupported-update-operation.error.d.mts.map

package/esm/errors/unsupported-update-operation.error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unsupported-update-operation.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-update-operation.error.ts"],"mappings":";;AAQA;;;;;;;cAAa,+BAAA,SAAwC,KAAK;EAkBrC;;;EAAA,SAdH,SAAA;EAcmD;;;EAAA,SATnD,MAAA;;;;;;;;cASG,SAAA,UAAmB,MAAA,UAAgB,IAAA;AAAA"}
+{"version":3,"file":"unsupported-update-operation.error.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/errors/unsupported-update-operation.error.ts"],"mappings":";;;;;;;;;qBAQa,wCAAwC;;;;WAInC;;;;WAKA;;;;;;;;EAShB,YAAmB,mBAAmB,gBAAgB"}

package/esm/events/model-events.d.mts

@@ -2,6 +2,8 @@ import { DeleteStrategy } from "../types.mjs";
 import { ModelSchema } from "../model/model.types.mjs";
 import { Model } from "../model/model.mjs";
 import { QueryBuilderContract } from "../contracts/query-builder.contract.mjs";
+import "../contracts/index.mjs";
+import "../index.mjs";
 //#region ../../packages/cascade/src/events/model-events.d.ts
 type OnValidatingEventContext = {
   isInsert: boolean;
@@ -16,7 +18,7 @@ type OnDeletingEventContext = {
   primaryKeyValue: string | number;
   primaryKey: string;
 };
-type OnDeletedEventContext = OnDeletingEventContext & {
+export type OnDeletedEventContext = OnDeletingEventContext & {
   deletedCount: number;
   trashRecord?: Record<string, unknown>;
 };
@@ -39,9 +41,9 @@ type OnFetchedEventContext = {
  * The list mirrors the hooks in the legacy ORM so downstream code can subscribe
  * with consistent semantics.
  */
-type ModelEventName = "fetching" | "hydrating" | "fetched" | "validating" | "validated" | "saving" | "saved" | "creating" | "created" | "updating" | "updated" | "deleting" | "deleted" | "restoring" | "restored";
+export type ModelEventName = "fetching" | "hydrating" | "fetched" | "validating" | "validated" | "saving" | "saved" | "creating" | "created" | "updating" | "updated" | "deleting" | "deleted" | "restoring" | "restored";
 /** Signature of an event listener registered against a model lifecycle hook. */
-type ModelEventListener<TModel, TContext = unknown> = (model: TModel, context: TContext) => void | Promise<void>;
+export type ModelEventListener<TModel, TContext = unknown> = (model: TModel, context: TContext) => void | Promise<void>;
 /**
  * Light-weight async event emitter used to power model lifecycle hooks.
  *
@@ -49,7 +51,7 @@ type ModelEventListener<TModel, TContext = unknown> = (model: TModel, context: T
  * re-use it in drivers, writers, and other core services without pulling in
  * heavier event libraries.
  */
-declare class ModelEvents<TModel> {
+export declare class ModelEvents<TModel> {
   readonly listeners: Map<ModelEventName, Set<ModelEventListener<TModel, unknown>>>;
   /**
    * Register a listener for the given event.
@@ -228,7 +230,7 @@ declare class ModelEvents<TModel> {
  * Global event emitter invoked for every model instance, regardless of type.
  * Useful for cross-cutting concerns like auditing or request-scoped enrichment.
  */
-declare const globalModelEvents: ModelEvents<Model<ModelSchema>>;
+export declare const globalModelEvents: ModelEvents<Model<ModelSchema>>;
 //#endregion
-export { ModelEventListener, ModelEventName, ModelEvents, OnDeletedEventContext, globalModelEvents };
+export {};
 //# sourceMappingURL=model-events.d.mts.map

package/esm/events/model-events.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"model-events.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/events/model-events.ts"],"mappings":"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"}
+{"version":3,"file":"model-events.d.mts","names":["_$__0.ModelSchema"],"sources":["../../../../../../../../packages/cascade/src/events/model-events.ts"],"mappings":";;;;;;;KAIK;EACH;EACA;;KAGG;EACH;EACA;;KAGG;EACH,UAAU;EACV;EACA;;YAGU,wBAAwB;EAClC;EACA,cAAc;;KAGX;EACH;EACA;;KAGG;EACH,OAAO;EACP,mBAAmB,WAAW;;KAG3B;EACH,OAAO;EACP;EACA;;;;;;;;YASU;;YAkBA,mBAAmB,QAAQ,uBACrC,OAAO,QACP,SAAS,oBACC;;;;;;;;qBASC,YAAY;WACP,WAAS,IAAA,gBAAA,IAAA,mBAAA;;;;;EAMlB,GAAG,oBACR,OAAO,gBACP,UAAU,mBAAmB,QAAQ;;;;EAUhC,KAAK,oBACV,OAAO,gBACP,UAAU,mBAAmB,QAAQ;;;;EAehC,IAAI,oBACT,OAAO,gBACP,UAAU,mBAAmB,QAAQ;;;;EAe1B,KAAK,oBAChB,OAAO,gBACP,OAAO,QACP,SAAS,WACR;;;;EAaU,aAAa,oBACxB,OAAO,sBACP,UAAU,WACT;;;;EAOI;;;;;;;;;;EAaA,SAAS,WAAW,sBACzB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,QAAQ,oBAAoB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAYjE,WAAW,oBAChB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,UAAU,oBAAoB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAYnE,WAAW,oBAChB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,UAAU,oBAAoB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAYnE,WAAW,WAAW,wBAC3B,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,UAAU,WAAW,uBAC1B,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,aAAa,WAAW,0BAC7B,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,YAAY,oBACjB,UAAU,mBAAmB,QAAQ;;;;;;;;;;EAchC,WAAW,WAAW,wBAC3B,UAAU,mBAAmB,QAAQ;;;;;;;;;;EAchC,YAAY,WAAW,yBAC5B,UAAU,mBAAmB,QAAQ;;;;;;;;;;EAchC,UAAU,WAAW,uBAC1B,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,YAAY,oBACjB,UAAU,mBAAmB,QAAQ;;;;;;;;;EAahC,WAAW,oBAChB,UAAU,mBAAmB,QAAQ;;;;;;;;UAY/B;;;;;;qBAcG,mBAAiB,YAAA,MAAjBA"}

package/esm/expressions/aggregate-expressions.d.mts

@@ -1,5 +1,4 @@
 import { ColumnExpression, ColumnExpressionInput } from "./column-expressions.mjs";
-
 //#region ../../packages/cascade/src/expressions/aggregate-expressions.d.ts
 /**
  * Abstract aggregate expression format.
@@ -7,8 +6,10 @@ import { ColumnExpression, ColumnExpressionInput } from "./column-expressions.mj
  * This format is database-agnostic and will be translated by each driver
  * to their native syntax.
  */
-type AggregateExpression = {
-  /** The aggregate function type */__agg: AggregateFunction; /** The field to aggregate (null for count, or when `__expr` carries a composed expression) */
+export type AggregateExpression = {
+  /** The aggregate function type */
+  __agg: AggregateFunction;
+  /** The field to aggregate (null for count, or when `__expr` carries a composed expression) */
   __field: string | null;
   /**
    * A typed column expression to aggregate over, when the aggregate operates
@@ -21,18 +22,18 @@ type AggregateExpression = {
 /**
  * Supported aggregate functions.
  */
-type AggregateFunction = "count" | "countDistinct" | "sum" | "avg" | "min" | "max" | "first" | "last" | "distinct" | "floor";
+export type AggregateFunction = "count" | "countDistinct" | "sum" | "avg" | "min" | "max" | "first" | "last" | "distinct" | "floor";
 /**
  * Checks if a value is an abstract aggregate expression.
  */
-declare function isAggregateExpression(value: unknown): value is AggregateExpression;
+export declare function isAggregateExpression(value: unknown): value is AggregateExpression;
 /**
  * Database-agnostic aggregation expression helpers.
  *
  * These helpers create abstract expressions that each driver translates
  * to their native format.
  */
-declare const $agg: {
+export declare const $agg: {
   /**
    * Count documents in each group.
    *
@@ -257,5 +258,4 @@ declare const $agg: {
   last(field: string): AggregateExpression;
 };
 //#endregion
-export { $agg, AggregateExpression, AggregateFunction, isAggregateExpression };
 //# sourceMappingURL=aggregate-expressions.d.mts.map

package/esm/expressions/aggregate-expressions.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-expressions.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/expressions/aggregate-expressions.ts"],"mappings":";;;AAmFA;;;;;;AAAA,KA/CY,mBAAA;EAqJkB,kCAnJ5B,KAAA,EAAO,iBAAA,EAiMa;EA/LpB,OAAA;EA2OyB;;;;;;EApOzB,MAAA,GAAS,gBAAgB;AAAA;;;;KAMf,iBAAA;;;;iBAeI,qBAAA,CAAsB,KAAA,YAAiB,KAAA,IAAS,mBAAmB;;;;;;;cAetE,IAAA;EAoJS;;;;;;;;;;;;;;;;WAnIX,mBAAA;EAmP+B;;;;;;;;;;;;;;;;;;;;gCA3NV,mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8BnB,qBAAA,GAAwB,mBAAA;;;;;;;;;;;;;;;;;;;;;;;;8BA+BP,mBAAA;;;;;;;;;;;;;;;;;;sBAyBR,mBAAA;;;;;;;;;;;;;;;;;;sBAqBA,mBAAA;;;;;;;;;;;;;;;;;;sBAqBA,mBAAA;;;;;;;;;;;;;;;;;;;;2BAuBK,mBAAA;;;;;;;;;;;;;;;;;;;wBAsBH,mBAAA;;;;;;;;;;;;;;;;;;;;wBAuBA,mBAAA;;;;;;;;;;;;;;;;;;;;uBAuBD,mBAAA;AAAA"}
+{"version":3,"file":"aggregate-expressions.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/expressions/aggregate-expressions.ts"],"mappings":";;;;;;;;YAoCY;;EAEV,OAAO;;EAEP;;;;;;;EAOA,SAAS;;;;;YAMC;;;;wBAeI,sBAAsB,iBAAiB,SAAS;;;;;;;qBAenD;;;;;;;;;;;;;;;;;EAiBX,SAAS;;;;;;;;;;;;;;;;;;;;;EAwBT,cAAa,gBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B9B,IAAG,OAAQ,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;EA+BnC,OAAM,qBAAsB;;;;;;;;;;;;;;;;;;EAyB5B,IAAG,gBAAiB;;;;;;;;;;;;;;;;;;EAqBpB,IAAG,gBAAiB;;;;;;;;;;;;;;;;;;EAqBpB,IAAG,gBAAiB;;;;;;;;;;;;;;;;;;;;EAuBpB,SAAQ,gBAAiB;;;;;;;;;;;;;;;;;;;EAsBzB,MAAK,gBAAiB;;;;;;;;;;;;;;;;;;;;EAuBtB,MAAK,gBAAiB;;;;;;;;;;;;;;;;;;;;EAuBtB,KAAI,gBAAiB"}