supabase-typed-query 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -1,2 +1,989 @@
-export * from './src/index'
-export {}
+import { Brand, IO, IOTask, IOTask as Task, List, List as List$1, Option, Option as Option$1 } from "functype";
+
+//#region src/types.d.ts
+
+/**
+ * Core type definitions for supabase-typed-query
+ */
+/**
+ * Structure of a single schema within a database.
+ */
+interface SchemaDefinition {
+  Tables: Record<string, {
+    Row: object;
+    Insert: object;
+    Update: object;
+  }>;
+  Views?: Record<string, {
+    Row: object;
+  }>;
+  Functions?: Record<string, {
+    Args: object;
+    Returns: unknown;
+  }>;
+  Enums?: Record<string, unknown>;
+  CompositeTypes?: Record<string, unknown>;
+}
+/**
+ * Base schema interface that all databases must conform to.
+ * Consumer-provided Database types must extend this interface.
+ * Supports multiple schemas (public, custom schemas, etc.)
+ *
+ * Note: No index signature - TypeScript's structural typing allows additional properties.
+ * This permits Supabase's __InternalSupabase while maintaining type safety for valid schemas.
+ */
+interface DatabaseSchema {
+  public: SchemaDefinition;
+}
+/**
+ * Extracts a valid schema from a database type.
+ * Returns the schema if it's a valid SchemaDefinition, otherwise never.
+ * This ensures type-safe access to schema properties.
+ */
+type ValidSchema<DB extends DatabaseSchema, S extends string> = S extends keyof DB ? DB[S] extends SchemaDefinition ? DB[S] : never : never;
+/**
+ * Helper type to strip `__InternalSupabase` from Supabase-generated database types.
+ * Following Supabase's own pattern from SupabaseClient.
+ *
+ * @example
+ * ```typescript
+ * type Schemas = keyof TypedDatabase<Database>  // "public" | "inventory" (excludes __InternalSupabase)
+ * ```
+ */
+type TypedDatabase<DB> = Omit<DB, "__InternalSupabase">;
+/**
+ * Default Database type - used as fallback when no specific database type is provided.
+ * For proper type inference, consumers should pass their generated Database type as a generic.
+ */
+interface Database extends DatabaseSchema {
+  public: {
+    Tables: Record<string, {
+      Row: Record<string, unknown>;
+      Insert: Record<string, unknown>;
+      Update: Record<string, unknown>;
+    }>;
+    Views: Record<string, {
+      Row: Record<string, unknown>;
+    }>;
+    Functions: Record<string, {
+      Args: Record<string, unknown>;
+      Returns: unknown;
+    }>;
+    Enums: Record<string, unknown>;
+    CompositeTypes: Record<string, unknown>;
+  };
+}
+/**
+ * Schema names for a given database.
+ * Only includes keys whose values are valid SchemaDefinitions (have Tables property).
+ * This excludes __InternalSupabase by structure, not just by name - providing true type safety.
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ */
+type SchemaNames<DB extends DatabaseSchema = Database> = { [K in keyof DB]: DB[K] extends SchemaDefinition ? K : never }[keyof DB] & string;
+/**
+ * Table names for a given database schema.
+ * Uses ValidSchema for type-safe access - only valid SchemaDefinitions can be accessed.
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type TableNames<DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = keyof ValidSchema<DB, S>["Tables"] & string;
+/**
+ * Row type for a given table in a database schema.
+ * Uses ValidSchema for type-safe access.
+ * @typeParam T - The table name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type TableRow<T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Tables"][T]["Row"];
+/**
+ * Insert type for a given table in a database schema.
+ * Uses ValidSchema for type-safe access.
+ * @typeParam T - The table name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type TableInsert<T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Tables"][T]["Insert"];
+/**
+ * Update type for a given table in a database schema.
+ * Uses ValidSchema for type-safe access.
+ * @typeParam T - The table name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type TableUpdate<T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Tables"][T]["Update"];
+/**
+ * View names for a given database schema.
+ * Uses ValidSchema for type-safe access - only valid SchemaDefinitions can be accessed.
+ * Views are read-only and only have a Row type (no Insert/Update).
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type ViewNames<DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Views"] extends Record<string, {
+  Row: object;
+}> ? keyof ValidSchema<DB, S>["Views"] & string : never;
+/**
+ * Row type for a given view in a database schema.
+ * Views are read-only, so they only have a Row type (no Insert or Update).
+ * Uses ValidSchema for type-safe access.
+ * @typeParam V - The view name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type ViewRow<V extends ViewNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Views"] extends Record<string, {
+  Row: object;
+}> ? ValidSchema<DB, S>["Views"][V]["Row"] : never;
+/**
+ * Function names for a given database schema.
+ * Extracts the keys from the Functions record in the schema definition.
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type FunctionNames<DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Functions"] extends Record<string, unknown> ? keyof ValidSchema<DB, S>["Functions"] & string : never;
+/**
+ * Argument type for a given function in a database schema.
+ * @typeParam F - The function name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type FunctionArgs<F extends FunctionNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Functions"] extends Record<string, {
+  Args: unknown;
+  Returns: unknown;
+}> ? ValidSchema<DB, S>["Functions"][F]["Args"] : never;
+/**
+ * Return type for a given function in a database schema.
+ * @typeParam F - The function name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type FunctionReturns<F extends FunctionNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = ValidSchema<DB, S>["Functions"] extends Record<string, {
+  Args: unknown;
+  Returns: unknown;
+}> ? ValidSchema<DB, S>["Functions"][F]["Returns"] : never;
+type EmptyObject = Record<string, never>;
+interface QueryBuilder extends Promise<{
+  data: unknown;
+  error: unknown;
+}> {
+  select: (columns?: string) => QueryBuilder;
+  insert: (data: unknown) => QueryBuilder;
+  update: (data: unknown) => QueryBuilder;
+  upsert: (data: unknown, options?: {
+    onConflict?: string;
+  }) => QueryBuilder;
+  delete: () => QueryBuilder;
+  match: (query: Record<string, unknown>) => QueryBuilder;
+  eq: (column: string, value: unknown) => QueryBuilder;
+  neq: (column: string, value: unknown) => QueryBuilder;
+  gt: (column: string, value: unknown) => QueryBuilder;
+  gte: (column: string, value: unknown) => QueryBuilder;
+  lt: (column: string, value: unknown) => QueryBuilder;
+  lte: (column: string, value: unknown) => QueryBuilder;
+  like: (column: string, pattern: string) => QueryBuilder;
+  ilike: (column: string, pattern: string) => QueryBuilder;
+  is: (column: string, value: boolean | null) => QueryBuilder;
+  in: (column: string, values: unknown[]) => QueryBuilder;
+  or: (filters: string) => QueryBuilder;
+  single: () => QueryBuilder;
+  limit: (count: number) => QueryBuilder;
+  order: (column: string, options?: {
+    ascending?: boolean;
+  }) => QueryBuilder;
+}
+/**
+ * RPC query builder returned by client.rpc()
+ */
+interface RpcQueryBuilder extends Promise<{
+  data: unknown;
+  error: unknown;
+}> {
+  select: (columns?: string) => RpcQueryBuilder;
+  single: () => RpcQueryBuilder;
+  limit: (count: number) => RpcQueryBuilder;
+  order: (column: string, options?: {
+    ascending?: boolean;
+  }) => RpcQueryBuilder;
+}
+/**
+ * Supabase client type - accepts any client with compatible from(), schema(), and rpc() methods.
+ * Uses `unknown` return type to allow SupabaseClient<Database> from @supabase/supabase-js
+ * to be used directly without type casting.
+ *
+ * This interface is intentionally permissive to accept Supabase clients configured for
+ * different schemas (e.g., SupabaseClient<Database, "public", "custom_schema">).
+ * The Entity/PartitionedEntity functions use their own schema type parameter for type safety.
+ *
+ * Note: The DB type parameter is unused but kept for API consistency and future extensibility.
+ *
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ */
+interface SupabaseClientType<_DB extends DatabaseSchema = Database> {
+  from: (table: any) => any;
+  schema: (name: any) => any;
+  rpc: (...args: any[]) => any;
+}
+//#endregion
+//#region src/query/Query.d.ts
+type ComparisonOperators<V> = {
+  gte?: V;
+  gt?: V;
+  lte?: V;
+  lt?: V;
+  neq?: V;
+  like?: string;
+  ilike?: string;
+  in?: V[];
+  is?: null | boolean;
+};
+type WhereConditions<T extends object> = Partial<{ [K in keyof T]: T[K] | null | ComparisonOperators<T[K]> }> & {
+  gte?: Partial<{ [K in keyof T]?: T[K] }>;
+  gt?: Partial<{ [K in keyof T]?: T[K] }>;
+  lte?: Partial<{ [K in keyof T]?: T[K] }>;
+  lt?: Partial<{ [K in keyof T]?: T[K] }>;
+  neq?: Partial<{ [K in keyof T]?: T[K] }>;
+  like?: Partial<{ [K in keyof T]?: Extract<T[K], string> }>;
+  ilike?: Partial<{ [K in keyof T]?: Extract<T[K], string> }>;
+};
+/**
+ * Entity-specific WHERE conditions - no nested ComparisonOperators allowed.
+ * Entity API methods (getItems, updateItem, etc.) don't process nested operators.
+ * Use separate `is`, `wherein`, etc. parameters for these operations.
+ *
+ * @example
+ * // Correct Entity usage:
+ * Entity.getItems({ where: { code }, is: { used_at: null } })
+ *
+ * // Incorrect (use Query API instead for nested operators):
+ * Entity.getItems({ where: { code, used_at: { is: null } } }) // TypeScript error
+ */
+type EntityWhereConditions<T extends object> = Partial<{ [K in keyof T]: T[K] | null }>;
+type IsConditions<T extends object = EmptyObject> = Partial<Record<keyof T, null | boolean>>;
+type NotConditions<T extends object = EmptyObject> = {
+  is?: Partial<Record<keyof T, null | boolean>>;
+  in?: Partial<Record<keyof T, unknown[]>>;
+};
+type SoftDeleteMode = "include" | "exclude" | "only";
+/**
+ * Base execution interface that all database operations implement
+ */
+interface ExecutableQuery<T> {
+  execute(): IOTask<Error, T>;
+  executeOrThrow(): Promise<T>;
+}
+/**
+ * Standard interface for operations that return a single result
+ */
+interface SingleExecution<T> extends ExecutableQuery<Option$1<T>> {
+  one(): IOTask<Error, Option$1<T>>;
+  oneOrThrow(): Promise<T>;
+}
+/**
+ * Standard interface for operations that return multiple results
+ */
+interface MultiExecution<T> extends ExecutableQuery<List$1<T>> {
+  many(): IOTask<Error, List$1<T>>;
+  manyOrThrow(): Promise<List$1<T>>;
+}
+/**
+ * Core Query interface with branded type support.
+ * Simplified to take just the Row type for better TypeScript performance.
+ *
+ * @typeParam Row - The row type for the table
+ */
+interface Query<Row extends object> {
+  one(): IOTask<Error, Option$1<Row>>;
+  many(): IOTask<Error, List$1<Row>>;
+  first(): IOTask<Error, Option$1<Row>>;
+  oneOrThrow(): Promise<Row>;
+  manyOrThrow(): Promise<List$1<Row>>;
+  firstOrThrow(): Promise<Row>;
+  or(where: WhereConditions<Row>, is?: IsConditions<Row>): Query<Row>;
+  whereId<ID extends Brand<string, string>>(id: ID): Query<Row>;
+  orWhereId<ID extends Brand<string, string>>(id: ID): Query<Row>;
+  map<U>(fn: (item: Row) => U): MappedQuery<U>;
+  filter(predicate: (item: Row) => boolean): Query<Row>;
+  limit(count: number): Query<Row>;
+  offset(count: number): Query<Row>;
+  includeDeleted(): Query<Row>;
+  excludeDeleted(): Query<Row>;
+  onlyDeleted(): Query<Row>;
+}
+interface MappedQuery<U> {
+  one(): IOTask<Error, Option$1<U>>;
+  many(): IOTask<Error, List$1<U>>;
+  first(): IOTask<Error, Option$1<U>>;
+  oneOrThrow(): Promise<U>;
+  manyOrThrow(): Promise<List$1<U>>;
+  firstOrThrow(): Promise<U>;
+  map<V>(fn: (item: U) => V): MappedQuery<V>;
+  filter(predicate: (item: U) => boolean): MappedQuery<U>;
+}
+/**
+ * Query condition for internal state management with type-safe where.
+ *
+ * @typeParam Row - The row type
+ */
+interface QueryCondition<Row extends object> {
+  where: WhereConditions<Row>;
+  is?: IsConditions<Row>;
+  wherein?: Partial<Record<keyof Row, unknown[]>>;
+  gt?: Partial<Record<keyof Row, number | string | Date>>;
+  gte?: Partial<Record<keyof Row, number | string | Date>>;
+  lt?: Partial<Record<keyof Row, number | string | Date>>;
+  lte?: Partial<Record<keyof Row, number | string | Date>>;
+  neq?: Partial<Record<keyof Row, unknown>>;
+  like?: Partial<Record<keyof Row, string>>;
+  ilike?: Partial<Record<keyof Row, string>>;
+  not?: NotConditions<Row>;
+}
+/**
+ * Entity-specific query interfaces for better type safety.
+ *
+ * @typeParam Row - The row type
+ */
+interface EntityQuery<Row extends object> extends Query<Row> {
+  normalize(): NormalizedQuery<Row>;
+}
+/**
+ * Normalized query interface.
+ *
+ * @typeParam Row - The row type
+ */
+interface NormalizedQuery<Row extends object> {
+  one(): IOTask<Error, Option$1<Row>>;
+  many(): IOTask<Error, List$1<Row>>;
+  first(): IOTask<Error, Option$1<Row>>;
+}
+declare const isQuery: <Row extends object>(obj: unknown) => obj is Query<Row>;
+declare const isMappedQuery: <U>(obj: unknown) => obj is MappedQuery<U>;
+/**
+ * Utility types for query parameters with type safety.
+ * Simplified to take Row type directly.
+ *
+ * @typeParam Row - The row type
+ */
+type QueryWhereParams<Row extends object> = WhereConditions<Row>;
+type QueryIsParams<Row extends object> = IsConditions<Row>;
+type QueryWhereinParams<Row extends object> = Partial<Record<keyof Row, unknown[]>>;
+type QueryOrderParams<Row extends object> = [keyof Row & string, {
+  ascending?: boolean;
+  nullsFirst?: boolean;
+}];
+/**
+ * Builder configuration for query construction.
+ * Simplified to take Row type directly for better TypeScript performance.
+ *
+ * @typeParam Row - The row type
+ */
+interface QueryBuilderConfig<Row extends object> {
+  table: string;
+  conditions: QueryCondition<Row>[];
+  order?: QueryOrderParams<Row>;
+  mapFn?: (item: Row) => unknown;
+  filterFn?: (item: Row) => boolean;
+  limit?: number;
+  offset?: number;
+  softDeleteMode?: SoftDeleteMode;
+  softDeleteAppliedByDefault?: boolean;
+  /** Database schema to query (defaults to "public") */
+  schema?: string;
+}
+//#endregion
+//#region src/query/rpc.d.ts
+/**
+ * Options for RPC execution
+ */
+type RpcOptions = {
+  /** Database schema to query (defaults to "public") */
+  schema?: string;
+  /** Count option for the query */
+  count?: "exact" | "planned" | "estimated";
+};
+/**
+ * Single execution interface for RPC calls
+ */
+type RpcSingleExecution<T> = {
+  /**
+   * Execute and return Task<Error, Option<T>>
+   * Returns None if no result, Some(value) if result exists
+   * Call .run() or .runOrThrow() to execute
+   */
+  one: () => IOTask<Error, Option$1<T>>;
+  /**
+   * Execute and return T directly, throwing on error or no result
+   */
+  oneOrThrow: () => Promise<T>;
+};
+/**
+ * Multi execution interface for RPC calls
+ */
+type RpcMultiExecution<T> = {
+  /**
+   * Execute and return Task<Error, List<T>>
+   * Returns empty List if no results
+   * Call .run() or .runOrThrow() to execute
+   */
+  many: () => IOTask<Error, List$1<T>>;
+  /**
+   * Execute and return List<T> directly, throwing on error
+   */
+  manyOrThrow: () => Promise<List$1<T>>;
+};
+/**
+ * Combined RPC query execution interface
+ * Provides both single and multi-result execution methods
+ */
+type RpcExecution<T> = RpcSingleExecution<T> & RpcMultiExecution<T>;
+/**
+ * Creates an RPC query for invoking a PostgreSQL function.
+ *
+ * This function provides type-safe invocation of stored procedures/functions
+ * defined in your Supabase database. Return types are inferred from your
+ * generated Database types.
+ *
+ * @template F - The function name (must exist in database schema)
+ * @template DB - The database schema type
+ * @template S - The schema name (defaults to "public")
+ * @param client - The Supabase client instance
+ * @param functionName - The name of the PostgreSQL function to call
+ * @param args - Arguments to pass to the function (type-safe based on function definition)
+ * @param options - Optional configuration (schema, count)
+ * @returns An RpcExecution object with one(), oneOrThrow(), many(), manyOrThrow() methods
+ *
+ * @example
+ * ```typescript
+ * // Function returning a single object
+ * const userStats = await rpc(client, "get_user_stats", { user_id: "123" }).one()
+ * if (userStats.isOk()) {
+ *   const stats = userStats.orThrow()
+ *   if (stats.isSome()) {
+ *     console.log(stats.get())
+ *   }
+ * }
+ *
+ * // Function returning multiple rows
+ * const products = await rpc(client, "search_products", { query: "laptop", limit: 10 }).many()
+ * products.forEach(p => console.log(p.name))
+ *
+ * // Using OrThrow variants
+ * const stats = await rpc(client, "get_user_stats", { user_id: "123" }).oneOrThrow()
+ * const results = await rpc(client, "search_all").manyOrThrow()
+ *
+ * // Using custom schema
+ * const result = await rpc<"cleanup_data", Database, "agent_gate">(client, "cleanup_data").one()
+ * ```
+ */
+declare const rpc: <F extends FunctionNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>>(client: SupabaseClientType<DB>, functionName: F, args?: FunctionArgs<F, DB, S>, options?: RpcOptions) => RpcExecution<FunctionReturns<F, DB, S>>;
+//#endregion
+//#region src/query/index.d.ts
+type IsConditionsLocal<T extends object = EmptyObject> = Partial<Record<keyof T, null | boolean>>;
+/**
+ * Retrieves a single entity from the specified table.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to query
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the entity if found
+ */
+declare const getEntity: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, schema?: string) => IOTask<Error, TableRow<T, DB>>;
+/**
+ * Retrieves multiple entities from the specified table.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to query
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param order - Optional ordering parameters
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the entities if found
+ */
+declare const getEntities: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where?: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, order?: [keyof TableRow<T, DB> & string, {
+  ascending?: boolean;
+  nullsFirst?: boolean;
+}], schema?: string) => IOTask<Error, List$1<TableRow<T, DB>>>;
+/**
+ * Adds multiple entities to the specified table.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to insert into
+ * @param entities - The entities to add
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the added entities
+ */
+declare const addEntities: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, entities: TableInsert<T, DB>[], schema?: string) => IOTask<Error, List$1<TableRow<T, DB>>>;
+/**
+ * Updates a single entity in the specified table.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to update
+ * @param entities - The entity data to update
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the updated entity
+ */
+declare const updateEntity: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, entities: TableUpdate<T, DB>, where: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, schema?: string) => IOTask<Error, TableRow<T, DB>>;
+/**
+ * Upserts multiple entities in the specified table (insert or update on conflict).
+ * Uses Supabase's upsert() under the hood with onConflict resolution.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to upsert into
+ * @param entities - The entities to upsert
+ * @param identity - The column(s) to use for conflict resolution (default: "id")
+ * @param where - Additional conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the upserted entities
+ */
+declare const upsertEntities: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, entities: TableUpdate<T, DB>[], identity?: (keyof TableRow<T, DB> & string) | (keyof TableRow<T, DB> & string)[], where?: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, schema?: string) => IOTask<Error, List$1<TableRow<T, DB>>>;
+/**
+ * Deletes a single entity from the specified table.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to delete from
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the deleted entity
+ */
+declare const deleteEntity: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, schema?: string) => IOTask<Error, TableRow<T, DB>>;
+/**
+ * Deletes multiple entities from the specified table.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to delete from
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the deleted entities
+ */
+declare const deleteEntities: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, schema?: string) => IOTask<Error, List$1<TableRow<T, DB>>>;
+/**
+ * Soft deletes a single entity by setting the deleted timestamp.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to soft delete from
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the soft deleted entity
+ */
+declare const softDeleteEntity: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, schema?: string) => IOTask<Error, TableRow<T, DB>>;
+/**
+ * Soft deletes multiple entities by setting the deleted timestamp.
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to soft delete from
+ * @param where - Conditions to filter by
+ * @param is - IS conditions to filter by
+ * @param wherein - WHERE IN conditions to filter by
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Task resolving to the soft deleted entities
+ */
+declare const softDeleteEntities: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where: EntityWhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, schema?: string) => IOTask<Error, List$1<TableRow<T, DB>>>;
+/**
+ * Creates a new Query for the specified table with initial conditions.
+ * This is the new Query-based API that supports OR chaining and functional operations.
+ *
+ * @template T - The table name
+ * @template DB - The database schema type
+ * @param client - The Supabase client instance
+ * @param table - The table to query
+ * @param where - Initial WHERE conditions to filter by
+ * @param is - Initial IS conditions to filter by
+ * @param wherein - Initial WHERE IN conditions to filter by
+ * @param order - Optional ordering parameters
+ * @param schema - Database schema to query (defaults to "public")
+ * @returns A Query instance that supports chaining and lazy evaluation
+ *
+ * @example
+ * // Simple query
+ * const user = await query(client, "users", { id: "123" }).one()
+ *
+ * @example
+ * // Query with OR logic
+ * const users = await query(client, "users", { role: "admin" })
+ *   .or({ role: "moderator" })
+ *   .many()
+ *
+ * @example
+ * // Query with functional operations
+ * const names = await query(client, "users", { active: true })
+ *   .map(user => user.name)
+ *   .filter(name => name.startsWith('A'))
+ *   .many()
+ *
+ * @example
+ * // Query with custom schema
+ * const items = await query(client, "items", { active: true }, undefined, undefined, undefined, "inventory").many()
+ */
+declare const query: <T extends TableNames<DB>, DB extends DatabaseSchema = Database>(client: SupabaseClientType<DB>, table: T, where?: WhereConditions<TableRow<T, DB>>, is?: IsConditionsLocal<TableRow<T, DB>>, wherein?: Partial<Record<keyof TableRow<T, DB>, unknown[]>>, order?: [keyof TableRow<T, DB> & string, {
+  ascending?: boolean;
+  nullsFirst?: boolean;
+}], schema?: string) => Query<TableRow<T, DB>>;
+//#endregion
+//#region src/entity/types.d.ts
+/**
+ * Partition key can be a string or any branded string type
+ * This enables type-safe partition keys using functype's Brand/ValidatedBrand
+ */
+type PartitionKey = string | Brand<string, string>;
+/**
+ * Field-level type safety for queries
+ */
+type TypedRecord<T, V> = Partial<Record<keyof T, V>>;
+/**
+ * Configuration for standard Entity (no partition)
+ */
+type EntityConfig = {
+  /** Soft delete filtering. true = exclude deleted items, false = include deleted items */
+  softDelete: boolean;
+  /** Database schema to query (defaults to "public") */
+  schema?: string;
+};
+/**
+ * Configuration for PartitionedEntity
+ */
+type PartitionedEntityConfig = {
+  /** The database column name used for partitioning (e.g., "tenant_id") */
+  partitionField: string;
+  /** Soft delete filtering. true = exclude deleted items, false = include deleted items */
+  softDelete: boolean;
+  /** Database schema to query (defaults to "public") */
+  schema?: string;
+};
+type WhereParams<T extends object = EmptyObject> = {
+  where?: EntityWhereConditions<T>;
+};
+type IsParams<T extends object = EmptyObject> = {
+  is?: TypedRecord<T, null | boolean>;
+};
+type WhereinParams<T extends object = EmptyObject> = {
+  wherein?: TypedRecord<T, unknown[]>;
+};
+type OrderParams<T extends object = EmptyObject> = {
+  order?: [keyof T & string, {
+    ascending?: boolean;
+    nullsFirst?: boolean;
+  }];
+};
+type ComparisonParams<T extends object = EmptyObject> = {
+  gte?: TypedRecord<T, number | string | Date>;
+  gt?: TypedRecord<T, number | string | Date>;
+  lte?: TypedRecord<T, number | string | Date>;
+  lt?: TypedRecord<T, number | string | Date>;
+  neq?: TypedRecord<T, unknown>;
+  like?: TypedRecord<T, string>;
+  ilike?: TypedRecord<T, string>;
+};
+type NotParams<T extends object = EmptyObject> = {
+  not?: {
+    is?: TypedRecord<T, null | boolean>;
+    in?: TypedRecord<T, unknown[]>;
+  };
+};
+type IdParam = {
+  id: string;
+};
+type GetItemParams<T extends object = EmptyObject> = IdParam & WhereParams<T> & IsParams<T>;
+type GetItemsParams<T extends object = EmptyObject> = WhereParams<T> & IsParams<T> & WhereinParams<T> & OrderParams<T> & ComparisonParams<T> & NotParams<T>;
+type AddItemsParams<T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  items: TableInsert<T, DB, S>[];
+};
+/**
+ * Prisma-style update params for single item: { where, data }
+ */
+type UpdateItemParams<T extends TableNames<DB, S>, Row extends object = EmptyObject, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  /** Conditions to match the item to update */
+  where: EntityWhereConditions<Row>;
+  /** The data to update */
+  data: TableUpdate<T, DB, S>;
+} & IsParams<Row> & WhereinParams<Row>;
+/**
+ * Prisma-style update params for multiple items: { where, data }
+ */
+type UpdateItemsParams<T extends TableNames<DB, S>, Row extends object = EmptyObject, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  /** Conditions to match items to update */
+  where: EntityWhereConditions<Row>;
+  /** The data to update on all matched items */
+  data: TableUpdate<T, DB, S>;
+} & IsParams<Row> & WhereinParams<Row>;
+/**
+ * Batch upsert params: update multiple rows with different data per row
+ */
+type UpsertItemsParams<T extends TableNames<DB, S>, Row extends object = EmptyObject, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  /** Array of items to upsert, each with its own data */
+  items: TableUpdate<T, DB, S>[];
+  /** Column(s) to use as identity for matching (default: "id") */
+  identity?: (keyof Row & string) | (keyof Row & string)[];
+};
+/**
+ * Delete params for single item: { where }
+ */
+type DeleteItemParams<Row extends object = EmptyObject> = {
+  /** Conditions to match the item to delete */
+  where: EntityWhereConditions<Row>;
+} & IsParams<Row> & WhereinParams<Row>;
+/**
+ * Delete params for multiple items: { where }
+ */
+type DeleteItemsParams<Row extends object = EmptyObject> = {
+  /** Conditions to match items to delete */
+  where: EntityWhereConditions<Row>;
+} & IsParams<Row> & WhereinParams<Row>;
+/**
+ * Wrapper type for multi-result mutation operations that implements standard execution interface
+ */
+type MutationMultiExecution<T> = MultiExecution<T>;
+/**
+ * Wrapper type for single-result mutation operations that implements standard execution interface
+ */
+type MutationSingleExecution<T> = SingleExecution<T>;
+/**
+ * Creates a multi-result mutation query that implements the standard execution interface
+ */
+declare function MultiMutationQuery<T>(task: IOTask<Error, List$1<T>>): MutationMultiExecution<T>;
+/**
+ * Creates a single-result mutation query that implements the standard execution interface
+ */
+declare function SingleMutationQuery<T>(task: IOTask<Error, T>): MutationSingleExecution<T>;
+/**
+ * Base interface for Entity instances (global, no partition)
+ *
+ * @typeParam T - The table name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type IEntity<T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  getItem(params: GetItemParams<TableRow<T, DB, S>>): Query<TableRow<T, DB, S>>;
+  getItems(params?: GetItemsParams<TableRow<T, DB, S>>): Query<TableRow<T, DB, S>>;
+  addItems(params: AddItemsParams<T, DB, S>): MutationMultiExecution<TableRow<T, DB, S>>;
+  updateItem(params: UpdateItemParams<T, TableRow<T, DB, S>, DB, S>): MutationSingleExecution<TableRow<T, DB, S>>;
+  updateItems(params: UpdateItemsParams<T, TableRow<T, DB, S>, DB, S>): MutationMultiExecution<TableRow<T, DB, S>>;
+  upsertItems(params: UpsertItemsParams<T, TableRow<T, DB, S>, DB, S>): MutationMultiExecution<TableRow<T, DB, S>>;
+  deleteItem(params: DeleteItemParams<TableRow<T, DB, S>>): MutationSingleExecution<TableRow<T, DB, S>>;
+  deleteItems(params: DeleteItemsParams<TableRow<T, DB, S>>): MutationMultiExecution<TableRow<T, DB, S>>;
+};
+/**
+ * Interface for PartitionedEntity instances (requires partition key on calls)
+ *
+ * @typeParam T - The table name
+ * @typeParam K - The partition key type
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type IPartitionedEntity<T extends TableNames<DB, S>, K$1 extends PartitionKey, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  getItem(partitionKey: K$1, params: GetItemParams<TableRow<T, DB, S>>): Query<TableRow<T, DB, S>>;
+  getItems(partitionKey: K$1, params?: GetItemsParams<TableRow<T, DB, S>>): Query<TableRow<T, DB, S>>;
+  addItems(params: AddItemsParams<T, DB, S>): MutationMultiExecution<TableRow<T, DB, S>>;
+  updateItem(partitionKey: K$1, params: UpdateItemParams<T, TableRow<T, DB, S>, DB, S>): MutationSingleExecution<TableRow<T, DB, S>>;
+  updateItems(partitionKey: K$1, params: UpdateItemsParams<T, TableRow<T, DB, S>, DB, S>): MutationMultiExecution<TableRow<T, DB, S>>;
+  upsertItems(partitionKey: K$1, params: UpsertItemsParams<T, TableRow<T, DB, S>, DB, S>): MutationMultiExecution<TableRow<T, DB, S>>;
+  deleteItem(partitionKey: K$1, params: DeleteItemParams<TableRow<T, DB, S>>): MutationSingleExecution<TableRow<T, DB, S>>;
+  deleteItems(partitionKey: K$1, params: DeleteItemsParams<TableRow<T, DB, S>>): MutationMultiExecution<TableRow<T, DB, S>>;
+};
+/**
+ * Type for an entity instance for a specific table
+ * @deprecated Use IEntity<T, DB, S> instead
+ */
+type EntityType<T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = IEntity<T, DB, S>;
+/**
+ * Configuration for ViewEntity (read-only, no partition)
+ */
+type ViewEntityConfig = {
+  /** Database schema to query (defaults to "public") */
+  schema?: string;
+};
+/**
+ * Configuration for PartitionedViewEntity
+ */
+type PartitionedViewEntityConfig = {
+  /** The database column name used for partitioning (e.g., "tenant_id") */
+  partitionField: string;
+  /** Database schema to query (defaults to "public") */
+  schema?: string;
+};
+/**
+ * Read-only interface for ViewEntity instances (global, no partition)
+ * Views only have Row type, so only read operations are available.
+ *
+ * @typeParam V - The view name
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type IViewEntity<V extends ViewNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  getItem(params: GetItemParams<ViewRow<V, DB, S>>): Query<ViewRow<V, DB, S>>;
+  getItems(params?: GetItemsParams<ViewRow<V, DB, S>>): Query<ViewRow<V, DB, S>>;
+};
+/**
+ * Read-only interface for PartitionedViewEntity instances (requires partition key on calls)
+ * Views only have Row type, so only read operations are available.
+ *
+ * @typeParam V - The view name
+ * @typeParam K - The partition key type
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ */
+type IPartitionedViewEntity<V extends ViewNames<DB, S>, K$1 extends PartitionKey, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>> = {
+  getItem(partitionKey: K$1, params: GetItemParams<ViewRow<V, DB, S>>): Query<ViewRow<V, DB, S>>;
+  getItems(partitionKey: K$1, params?: GetItemsParams<ViewRow<V, DB, S>>): Query<ViewRow<V, DB, S>>;
+};
+//#endregion
+//#region src/entity/Entity.d.ts
+/**
+ * Creates an entity interface with methods for interacting with the given table.
+ *
+ * @param client The Supabase client instance to use for queries.
+ * @param name The name of the table to interact with.
+ * @param config Configuration for entity behavior.
+ * @returns An object with methods for interacting with the table.
+ *
+ * @typeParam T - The table name type
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ *
+ * @example
+ * ```typescript
+ * // Using default public schema
+ * const Users = Entity<"users">(client, "users", { softDelete: false })
+ *
+ * // Using a custom schema
+ * const Tokens = Entity<"provider_tokens", Database, "agent_todo">(
+ *   client, "provider_tokens", { softDelete: false }
+ * )
+ * ```
+ */
+declare const Entity: <T extends TableNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>>(client: SupabaseClientType<DB>, name: T, config: EntityConfig) => IEntity<T, DB, S>;
+//#endregion
+//#region src/entity/PartitionedEntity.d.ts
+/**
+ * Creates a partitioned entity interface where all queries require a partition key.
+ *
+ * @param client The Supabase client instance to use for queries.
+ * @param name The name of the table to interact with.
+ * @param config Configuration including partition field and soft delete behavior.
+ * @returns An object with methods for interacting with the partitioned table.
+ *
+ * @typeParam T - The table name type
+ * @typeParam K - The partition key type (string or branded type)
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ *
+ * @example
+ * ```typescript
+ * // Using default public schema
+ * const UserEntity = PartitionedEntity<"users", TenantId>(client, "users", {
+ *   partitionField: "tenant_id",
+ *   softDelete: true
+ * })
+ *
+ * // Using a custom schema
+ * const TaskEntity = PartitionedEntity<"tasks", TenantId, Database, "agent_todo">(
+ *   client, "tasks", { partitionField: "user_id", softDelete: false }
+ * )
+ * ```
+ */
+declare const PartitionedEntity: <T extends TableNames<DB, S>, K$1 extends PartitionKey = string, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>>(client: SupabaseClientType<DB>, name: T, config: PartitionedEntityConfig) => IPartitionedEntity<T, K$1, DB, S>;
+//#endregion
+//#region src/entity/ViewEntity.d.ts
+/**
+ * Creates a read-only entity interface for querying database views.
+ *
+ * @param client The Supabase client instance to use for queries.
+ * @param name The name of the view to query.
+ * @param config Optional configuration for the view entity.
+ * @returns An object with read-only methods for querying the view.
+ *
+ * @typeParam V - The view name type
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ *
+ * @example
+ * ```typescript
+ * // Using default public schema
+ * const ActiveUsersView = ViewEntity<"active_users_view">(client, "active_users_view")
+ *
+ * // Using a custom schema
+ * const AuthUsersView = ViewEntity<"auth_users_view", Database, "agent_gate">(
+ *   client, "auth_users_view", { schema: "agent_gate" }
+ * )
+ * ```
+ */
+declare const ViewEntity: <V extends ViewNames<DB, S>, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>>(client: SupabaseClientType<DB>, name: V, config?: ViewEntityConfig) => IViewEntity<V, DB, S>;
+//#endregion
+//#region src/entity/PartitionedViewEntity.d.ts
+/**
+ * Creates a read-only partitioned entity interface for querying database views.
+ *
+ * @param client The Supabase client instance to use for queries.
+ * @param name The name of the view to query.
+ * @param config Configuration including partition field.
+ * @returns An object with read-only methods for querying the partitioned view.
+ *
+ * @typeParam V - The view name type
+ * @typeParam K - The partition key type (string or branded type)
+ * @typeParam DB - The database schema type (defaults to placeholder Database)
+ * @typeParam S - The schema name (defaults to "public")
+ *
+ * @example
+ * ```typescript
+ * // Using default public schema
+ * const TenantStatsView = PartitionedViewEntity<"tenant_stats_view", TenantId>(
+ *   client, "tenant_stats_view", { partitionField: "tenant_id" }
+ * )
+ *
+ * // Using a custom schema
+ * const UserActivityView = PartitionedViewEntity<"user_activity_view", UserId, Database, "analytics">(
+ *   client, "user_activity_view", { partitionField: "user_id", schema: "analytics" }
+ * )
+ * ```
+ */
+declare const PartitionedViewEntity: <V extends ViewNames<DB, S>, K$1 extends PartitionKey = string, DB extends DatabaseSchema = Database, S extends SchemaNames<DB> = "public" & SchemaNames<DB>>(client: SupabaseClientType<DB>, name: V, config: PartitionedViewEntityConfig) => IPartitionedViewEntity<V, K$1, DB, S>;
+//#endregion
+//#region src/utils/errors.d.ts
+/**
+ * Supabase/Postgrest error structure
+ */
+type SupabaseErrorObject = {
+  message: string;
+  code?: string;
+  details?: string;
+  hint?: string;
+};
+/**
+ * Custom Error class that preserves Supabase error details
+ */
+declare class SupabaseError extends Error {
+  readonly code?: string;
+  readonly details?: string;
+  readonly hint?: string;
+  constructor(error: SupabaseErrorObject | unknown);
+  /**
+   * Override toString to include all error details
+   */
+  toString(): string;
+}
+/**
+ * Convert any error to a proper Error instance
+ */
+declare const toError: (error: unknown) => Error;
+//#endregion
+export { type AddItemsParams, type ComparisonOperators, type Database, type DatabaseSchema, type DeleteItemParams, type DeleteItemsParams, type EmptyObject, Entity, type EntityConfig, type EntityQuery, type EntityType, type EntityWhereConditions, type ExecutableQuery, type FunctionArgs, type FunctionNames, type FunctionReturns, type GetItemParams, type GetItemsParams, type IEntity, IO, type IPartitionedEntity, type IPartitionedViewEntity, type IViewEntity, type IdParam, type IsConditions, type IsParams, List, type MappedQuery, type MultiExecution, MultiMutationQuery, type MutationMultiExecution, type MutationSingleExecution, Option, type OrderParams, type PartitionKey, PartitionedEntity, type PartitionedEntityConfig, PartitionedViewEntity, type PartitionedViewEntityConfig, type Query, type QueryBuilder, type QueryBuilderConfig, type QueryCondition, type QueryIsParams, type QueryOrderParams, type QueryWhereParams, type QueryWhereinParams, type RpcExecution, type RpcMultiExecution, type RpcOptions, type RpcQueryBuilder, type RpcSingleExecution, type SchemaNames, type SingleExecution, SingleMutationQuery, type SoftDeleteMode, type SupabaseClientType, SupabaseError, type SupabaseErrorObject, type TableInsert, type TableNames, type TableRow, type TableUpdate, type Task, type TypedDatabase, type TypedRecord, type UpdateItemParams, type UpdateItemsParams, type UpsertItemsParams, type ValidSchema, ViewEntity, type ViewEntityConfig, type ViewNames, type ViewRow, type WhereConditions, type WhereParams, type WhereinParams, addEntities, deleteEntities, deleteEntity, getEntities, getEntity, isMappedQuery, isQuery, query, rpc, softDeleteEntities, softDeleteEntity, toError, updateEntity, upsertEntities };
+//# sourceMappingURL=index.d.ts.map