postgresdk 0.18.3 → 0.18.5

package/dist/cli.js

@@ -3765,15 +3765,29 @@ export class ${Type}Client extends BaseClient {
   private readonly resource = "/v1/${table.name}";
 
 ${hasJsonbColumns ? `  /**
+   * Create a new ${table.name} record with field selection
+   * @param data - The data to insert
+   * @param options - Select specific fields to return
+   * @returns The created record with only selected fields
+   */
+  async create<TJsonb extends Partial<Select${Type}> = {}>(data: NoInfer<Insert${Type}<TJsonb>>, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>>>;
+  /**
+   * Create a new ${table.name} record with field exclusion
+   * @param data - The data to insert
+   * @param options - Exclude specific fields from return
+   * @returns The created record without excluded fields
+   */
+  async create<TJsonb extends Partial<Select${Type}> = {}>(data: NoInfer<Insert${Type}<TJsonb>>, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>>>;
+  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
-   * @param options - Optional select/exclude for returned fields
-   * @returns The created record
+   * @returns The created record with all fields
    * @example
    * // With JSONB type override:
    * type Metadata = { tags: string[]; prefs: { theme: 'light' | 'dark' } };
    * const user = await client.create<{ metadata: Metadata }>({ name: 'Alice', metadata: { tags: [], prefs: { theme: 'light' } } });
    */
+  async create<TJsonb extends Partial<Select${Type}> = {}>(data: NoInfer<Insert${Type}<TJsonb>>, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb>>;
   async create<TJsonb extends Partial<Select${Type}> = {}>(
     data: NoInfer<Insert${Type}<TJsonb>>,
     options?: { select?: string[]; exclude?: string[] }
@@ -3785,11 +3799,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}?\${query}\` : this.resource;
     return this.post<Select${Type}<TJsonb>>(url, data);
   }` : `  /**
+   * Create a new ${table.name} record with field selection
+   * @param data - The data to insert
+   * @param options - Select specific fields to return
+   * @returns The created record with only selected fields
+   */
+  async create(data: Insert${Type}, options: { select: string[] }): Promise<Partial<Select${Type}>>;
+  /**
+   * Create a new ${table.name} record with field exclusion
+   * @param data - The data to insert
+   * @param options - Exclude specific fields from return
+   * @returns The created record without excluded fields
+   */
+  async create(data: Insert${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}>>;
+  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
-   * @param options - Optional select/exclude for returned fields
-   * @returns The created record
+   * @returns The created record with all fields
    */
+  async create(data: Insert${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}>;
   async create(
     data: Insert${Type},
     options?: { select?: string[]; exclude?: string[] }
@@ -3803,14 +3831,28 @@ ${hasJsonbColumns ? `  /**
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * Get a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The record with only selected fields if found, null otherwise
+   */
+  async getByPk<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
+   * Get a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The record without excluded fields if found, null otherwise
+   */
+  async getByPk<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The record if found, null otherwise
+   * @returns The record with all fields if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.getByPk<{ metadata: Metadata }>('user-id');
    */
+  async getByPk<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb> | null>;
   async getByPk<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -3823,11 +3865,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.get<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Get a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The record with only selected fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Get a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The record without excluded fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The record if found, null otherwise
+   * @returns The record with all fields if found, null otherwise
    */
+  async getByPk(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async getByPk(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -3842,24 +3898,73 @@ ${hasJsonbColumns ? `  /**
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * List ${table.name} records with field selection
+   * @param params - Query parameters with select
+   * @returns Paginated results with only selected fields
+   */
+  async list<TJsonb extends Partial<Select${Type}> = {}>(params: {
+    select: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}<TJsonb>>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
+   * List ${table.name} records with field exclusion
+   * @param params - Query parameters with exclude
+   * @returns Paginated results without excluded fields
+   */
+  async list<TJsonb extends Partial<Select${Type}> = {}>(params: {
+    exclude: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}<TJsonb>>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
-   * @param params.select - Array of field names to include in response
-   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
-   * @returns Paginated results with data, total count, and hasMore flag
+   * @returns Paginated results with all fields
    * @example
    * // With JSONB type override:
    * const users = await client.list<{ metadata: Metadata }>({ where: { status: 'active' } });
-   * @example
-   * // With select:
-   * const users = await client.list({ select: ['id', 'email'] });
    */
+  async list<TJsonb extends Partial<Select${Type}> = {}>(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
   async list<TJsonb extends Partial<Select${Type}> = {}>(params?: {
     include?: any;
     select?: string[];
@@ -3875,24 +3980,73 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<(Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>>> {
     return this.post<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }` : `  /**
+   * List ${table.name} records with field selection
+   * @param params - Query parameters with select
+   * @returns Paginated results with only selected fields
+   */
+  async list(params: {
+    select: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
+   * List ${table.name} records with field exclusion
+   * @param params - Query parameters with exclude
+   * @returns Paginated results without excluded fields
+   */
+  async list(params: {
+    exclude: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
-   * @param params.select - Array of field names to include in response
-   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
-   * @returns Paginated results with data, total count, and hasMore flag
-   * @example
-   * // With select:
-   * const users = await client.list({ select: ['id', 'email'] });
+   * @returns Paginated results with all fields
    */
+  async list(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
   async list(params?: {
     include?: any;
     select?: string[];
@@ -3908,20 +4062,36 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<(Select${Type} | Partial<Select${Type}>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<Select${Type} | Partial<Select${Type}>>> {
     return this.post<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * Update a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Select specific fields to return
+   * @returns The updated record with only selected fields if found, null otherwise
+   */
+  async update<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, patch: NoInfer<Update${Type}<TJsonb>>, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
+   * Update a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Exclude specific fields from return
+   * @returns The updated record without excluded fields if found, null otherwise
+   */
+  async update<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, patch: NoInfer<Update${Type}<TJsonb>>, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
-   * @param options - Optional select/exclude for returned fields
-   * @returns The updated record if found, null otherwise
+   * @returns The updated record with all fields if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.update<{ metadata: Metadata }>('user-id', { metadata: { tags: ['new'] } });
    */
+  async update<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, patch: NoInfer<Update${Type}<TJsonb>>, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb> | null>;
   async update<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
     patch: NoInfer<Update${Type}<TJsonb>>,
@@ -3935,12 +4105,28 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.patch<Select${Type}<TJsonb> | null>(url, patch);
   }` : `  /**
+   * Update a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Select specific fields to return
+   * @returns The updated record with only selected fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Update a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Exclude specific fields from return
+   * @returns The updated record without excluded fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
-   * @param options - Optional select/exclude for returned fields
-   * @returns The updated record if found, null otherwise
+   * @returns The updated record with all fields if found, null otherwise
    */
+  async update(pk: ${pkType}, patch: Update${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async update(
     pk: ${pkType},
     patch: Update${Type},
@@ -3956,14 +4142,28 @@ ${hasJsonbColumns ? `  /**
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * Delete a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The deleted record with only selected fields if found, null otherwise
+   */
+  async delete<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
+   * Delete a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The deleted record without excluded fields if found, null otherwise
+   */
+  async delete<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The deleted record if found, null otherwise
+   * @returns The deleted record with all fields if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.delete<{ metadata: Metadata }>('user-id');
    */
+  async delete<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb> | null>;
   async delete<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -3976,11 +4176,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.del<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Delete a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The deleted record with only selected fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Delete a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The deleted record without excluded fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The deleted record if found, null otherwise
+   * @returns The deleted record with all fields if found, null otherwise
    */
+  async delete(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async delete(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }

package/dist/index.js

@@ -2786,15 +2786,29 @@ export class ${Type}Client extends BaseClient {
   private readonly resource = "/v1/${table.name}";
 
 ${hasJsonbColumns ? `  /**
+   * Create a new ${table.name} record with field selection
+   * @param data - The data to insert
+   * @param options - Select specific fields to return
+   * @returns The created record with only selected fields
+   */
+  async create<TJsonb extends Partial<Select${Type}> = {}>(data: NoInfer<Insert${Type}<TJsonb>>, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>>>;
+  /**
+   * Create a new ${table.name} record with field exclusion
+   * @param data - The data to insert
+   * @param options - Exclude specific fields from return
+   * @returns The created record without excluded fields
+   */
+  async create<TJsonb extends Partial<Select${Type}> = {}>(data: NoInfer<Insert${Type}<TJsonb>>, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>>>;
+  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
-   * @param options - Optional select/exclude for returned fields
-   * @returns The created record
+   * @returns The created record with all fields
    * @example
    * // With JSONB type override:
    * type Metadata = { tags: string[]; prefs: { theme: 'light' | 'dark' } };
    * const user = await client.create<{ metadata: Metadata }>({ name: 'Alice', metadata: { tags: [], prefs: { theme: 'light' } } });
    */
+  async create<TJsonb extends Partial<Select${Type}> = {}>(data: NoInfer<Insert${Type}<TJsonb>>, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb>>;
   async create<TJsonb extends Partial<Select${Type}> = {}>(
     data: NoInfer<Insert${Type}<TJsonb>>,
     options?: { select?: string[]; exclude?: string[] }
@@ -2806,11 +2820,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}?\${query}\` : this.resource;
     return this.post<Select${Type}<TJsonb>>(url, data);
   }` : `  /**
+   * Create a new ${table.name} record with field selection
+   * @param data - The data to insert
+   * @param options - Select specific fields to return
+   * @returns The created record with only selected fields
+   */
+  async create(data: Insert${Type}, options: { select: string[] }): Promise<Partial<Select${Type}>>;
+  /**
+   * Create a new ${table.name} record with field exclusion
+   * @param data - The data to insert
+   * @param options - Exclude specific fields from return
+   * @returns The created record without excluded fields
+   */
+  async create(data: Insert${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}>>;
+  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
-   * @param options - Optional select/exclude for returned fields
-   * @returns The created record
+   * @returns The created record with all fields
    */
+  async create(data: Insert${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}>;
   async create(
     data: Insert${Type},
     options?: { select?: string[]; exclude?: string[] }
@@ -2824,14 +2852,28 @@ ${hasJsonbColumns ? `  /**
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * Get a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The record with only selected fields if found, null otherwise
+   */
+  async getByPk<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
+   * Get a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The record without excluded fields if found, null otherwise
+   */
+  async getByPk<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The record if found, null otherwise
+   * @returns The record with all fields if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.getByPk<{ metadata: Metadata }>('user-id');
    */
+  async getByPk<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb> | null>;
   async getByPk<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -2844,11 +2886,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.get<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Get a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The record with only selected fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Get a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The record without excluded fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The record if found, null otherwise
+   * @returns The record with all fields if found, null otherwise
    */
+  async getByPk(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async getByPk(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -2863,24 +2919,73 @@ ${hasJsonbColumns ? `  /**
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * List ${table.name} records with field selection
+   * @param params - Query parameters with select
+   * @returns Paginated results with only selected fields
+   */
+  async list<TJsonb extends Partial<Select${Type}> = {}>(params: {
+    select: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}<TJsonb>>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
+   * List ${table.name} records with field exclusion
+   * @param params - Query parameters with exclude
+   * @returns Paginated results without excluded fields
+   */
+  async list<TJsonb extends Partial<Select${Type}> = {}>(params: {
+    exclude: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}<TJsonb>>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
-   * @param params.select - Array of field names to include in response
-   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
-   * @returns Paginated results with data, total count, and hasMore flag
+   * @returns Paginated results with all fields
    * @example
    * // With JSONB type override:
    * const users = await client.list<{ metadata: Metadata }>({ where: { status: 'active' } });
-   * @example
-   * // With select:
-   * const users = await client.list({ select: ['id', 'email'] });
    */
+  async list<TJsonb extends Partial<Select${Type}> = {}>(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
   async list<TJsonb extends Partial<Select${Type}> = {}>(params?: {
     include?: any;
     select?: string[];
@@ -2896,24 +3001,73 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<(Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>>> {
     return this.post<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }` : `  /**
+   * List ${table.name} records with field selection
+   * @param params - Query parameters with select
+   * @returns Paginated results with only selected fields
+   */
+  async list(params: {
+    select: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
+   * List ${table.name} records with field exclusion
+   * @param params - Query parameters with exclude
+   * @returns Paginated results without excluded fields
+   */
+  async list(params: {
+    exclude: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
-   * @param params.select - Array of field names to include in response
-   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
-   * @returns Paginated results with data, total count, and hasMore flag
-   * @example
-   * // With select:
-   * const users = await client.list({ select: ['id', 'email'] });
+   * @returns Paginated results with all fields
    */
+  async list(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
   async list(params?: {
     include?: any;
     select?: string[];
@@ -2929,20 +3083,36 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<(Select${Type} | Partial<Select${Type}>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<Select${Type} | Partial<Select${Type}>>> {
     return this.post<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * Update a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Select specific fields to return
+   * @returns The updated record with only selected fields if found, null otherwise
+   */
+  async update<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, patch: NoInfer<Update${Type}<TJsonb>>, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
+   * Update a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Exclude specific fields from return
+   * @returns The updated record without excluded fields if found, null otherwise
+   */
+  async update<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, patch: NoInfer<Update${Type}<TJsonb>>, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
-   * @param options - Optional select/exclude for returned fields
-   * @returns The updated record if found, null otherwise
+   * @returns The updated record with all fields if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.update<{ metadata: Metadata }>('user-id', { metadata: { tags: ['new'] } });
    */
+  async update<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, patch: NoInfer<Update${Type}<TJsonb>>, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb> | null>;
   async update<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
     patch: NoInfer<Update${Type}<TJsonb>>,
@@ -2956,12 +3126,28 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.patch<Select${Type}<TJsonb> | null>(url, patch);
   }` : `  /**
+   * Update a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Select specific fields to return
+   * @returns The updated record with only selected fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Update a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Exclude specific fields from return
+   * @returns The updated record without excluded fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
-   * @param options - Optional select/exclude for returned fields
-   * @returns The updated record if found, null otherwise
+   * @returns The updated record with all fields if found, null otherwise
    */
+  async update(pk: ${pkType}, patch: Update${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async update(
     pk: ${pkType},
     patch: Update${Type},
@@ -2977,14 +3163,28 @@ ${hasJsonbColumns ? `  /**
   }`}
 
 ${hasJsonbColumns ? `  /**
+   * Delete a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The deleted record with only selected fields if found, null otherwise
+   */
+  async delete<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
+   * Delete a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The deleted record without excluded fields if found, null otherwise
+   */
+  async delete<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}<TJsonb>> | null>;
+  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The deleted record if found, null otherwise
+   * @returns The deleted record with all fields if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.delete<{ metadata: Metadata }>('user-id');
    */
+  async delete<TJsonb extends Partial<Select${Type}> = {}>(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}<TJsonb> | null>;
   async delete<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -2997,11 +3197,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.del<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Delete a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The deleted record with only selected fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Delete a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The deleted record without excluded fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The deleted record if found, null otherwise
+   * @returns The deleted record with all fields if found, null otherwise
    */
+  async delete(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async delete(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {