use orWhere instead $or in generated client for better type safety

api/scripts/generate_typescript.ts

···
     ],
   });
 
-  // Where clause type with OR support
+  // Where clause type - simple mapped type for direct use
   sourceFile.addTypeAlias({
     name: "WhereClause",
     typeParameters: [{ name: "T", constraint: "string", default: "string" }],
     isExported: true,
-    type: "Partial<Record<T, WhereCondition>> & { $or?: Partial<Record<T, WhereCondition>> }",
+    type: "{ [K in T]?: WhereCondition }",
   });
+
 
   // IndexedRecord fields that are always available for filtering
   sourceFile.addTypeAlias({
···
     ],
   });
 
-  // Unified params for single endpoint
+  // Unified params for single endpoint with separate where and orWhere
   sourceFile.addInterface({
     name: "SliceRecordsParams",
     typeParameters: [
···
       { name: "cursor", type: "string", hasQuestionToken: true },
       {
         name: "where",
-        type: "WhereClause<TSortField | IndexedRecordFields>",
+        type: "{ [K in TSortField | IndexedRecordFields]?: WhereCondition }",
+        hasQuestionToken: true,
+      },
+      {
+        name: "orWhere",
+        type: "{ [K in TSortField | IndexedRecordFields]?: WhereCondition }",
         hasQuestionToken: true,
       },
       {
···
     ],
   });
 
-  // Slice-level params (allows any field name for cross-collection queries)
+  // Slice-level params with generic type support for field names
   sourceFile.addInterface({
     name: "SliceLevelRecordsParams",
+    typeParameters: [{ name: "TRecord", default: "Record<string, unknown>" }],
     isExported: true,
     properties: [
       { name: "slice", type: "string" },
···
       { name: "cursor", type: "string", hasQuestionToken: true },
       {
         name: "where",
-        type: "WhereClause<string>",
+        type: "{ [K in keyof TRecord | IndexedRecordFields]?: WhereCondition }",
+        hasQuestionToken: true,
+      },
+      {
+        name: "orWhere",
+        type: "{ [K in keyof TRecord | IndexedRecordFields]?: WhereCondition }",
         hasQuestionToken: true,
       },
       {
···
           parameters: [
             {
               name: "params",
-              type: `{ limit?: number; cursor?: string; where?: WhereClause<${whereFieldsType}>; sortBy?: SortField<${sortFieldsType}>[]; }`,
+              type: `{ limit?: number; cursor?: string; where?: { [K in ${whereFieldsType}]?: WhereCondition }; orWhere?: { [K in ${whereFieldsType}]?: WhereCondition }; sortBy?: SortField<${sortFieldsType}>[]; }`,
               hasQuestionToken: true,
             },
           ],
···
           parameters: [
             {
               name: "params",
-              type: `{ limit?: number; cursor?: string; where?: WhereClause<${whereFieldsType}>; sortBy?: SortField<${sortFieldsType}>[]; }`,
+              type: `{ limit?: number; cursor?: string; where?: { [K in ${whereFieldsType}]?: WhereCondition }; orWhere?: { [K in ${whereFieldsType}]?: WhereCondition }; sortBy?: SortField<${sortFieldsType}>[]; }`,
               hasQuestionToken: true,
             },
           ],
···
         if (method.name === "getRecords") {
           const recordType = obj._recordType as string;
           methodDecl.addStatements([
-            `const requestParams = { ...params, slice: this.sliceUri };`,
+            `// Combine where and orWhere into the expected backend format`,
+            `const whereClause: any = params?.where ? { ...params.where } : {};`,
+            `if (params?.orWhere) {`,
+            `  whereClause.$or = params.orWhere;`,
+            `}`,
+            `const requestParams = {`,
+            `  ...params,`,
+            `  where: Object.keys(whereClause).length > 0 ? whereClause : undefined,`,
+            `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
+            `  slice: this.sliceUri`,
+            `};`,
             `const result = await this.makeRequest<SliceRecordsOutput>('${collectionPath}.getRecords', 'POST', requestParams);`,
             `return {`,
             `  records: result.records.map(record => ({`,
···
           ]);
         } else if (method.name === "countRecords") {
           methodDecl.addStatements([
-            `const requestParams = { ...params, slice: this.sliceUri };`,
+            `// Combine where and orWhere into the expected backend format`,
+            `const whereClause: any = params?.where ? { ...params.where } : {};`,
+            `if (params?.orWhere) {`,
+            `  whereClause.$or = params.orWhere;`,
+            `}`,
+            `const requestParams = {`,
+            `  ...params,`,
+            `  where: Object.keys(whereClause).length > 0 ? whereClause : undefined,`,
+            `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
+            `  slice: this.sliceUri`,
+            `};`,
             `return await this.makeRequest<CountRecordsResponse>('${collectionPath}.countRecords', 'POST', requestParams);`,
           ]);
         }
···
           name: "getSliceRecords",
           typeParameters: [{ name: "T", default: "Record<string, unknown>" }],
           parameters: [
-            { name: "params", type: "Omit<SliceLevelRecordsParams, 'slice'>" },
+            { name: "params", type: "Omit<SliceLevelRecordsParams<T>, 'slice'>" },
           ],
           returnType: "Promise<SliceRecordsOutput<T>>",
           isAsync: true,
           statements: [
-            `const requestParams = { ...params, slice: this.sliceUri };`,
+            `// Combine where and orWhere into the expected backend format`,
+            `const whereClause: any = params?.where ? { ...params.where } : {};`,
+            `if (params?.orWhere) {`,
+            `  whereClause.$or = params.orWhere;`,
+            `}`,
+            `const requestParams = {`,
+            `  ...params,`,
+            `  where: Object.keys(whereClause).length > 0 ? whereClause : undefined,`,
+            `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
+            `  slice: this.sliceUri`,
+            `};`,
             `return await this.makeRequest<SliceRecordsOutput<T>>('social.slices.slice.getSliceRecords', 'POST', requestParams);`,
           ],
         });
···
           name: "getSliceRecords",
           typeParameters: [{ name: "T", default: "Record<string, unknown>" }],
           parameters: [
-            { name: "params", type: "Omit<SliceLevelRecordsParams, 'slice'>" },
+            { name: "params", type: "Omit<SliceLevelRecordsParams<T>, 'slice'>" },
           ],
           returnType: "Promise<SliceRecordsOutput<T>>",
           isAsync: true,
           statements: [
-            `const requestParams = { ...params, slice: this.sliceUri };`,
+            `// Combine where and orWhere into the expected backend format`,
+            `const whereClause: any = params?.where ? { ...params.where } : {};`,
+            `if (params?.orWhere) {`,
+            `  whereClause.$or = params.orWhere;`,
+            `}`,
+            `const requestParams = {`,
+            `  ...params,`,
+            `  where: Object.keys(whereClause).length > 0 ? whereClause : undefined,`,
+            `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
+            `  slice: this.sliceUri`,
+            `};`,
             `return await this.makeRequest<SliceRecordsOutput<T>>('social.slices.slice.getSliceRecords', 'POST', requestParams);`,
           ],
         });

docs/sdk-usage.md

···
   },
 });
 
+// Count with OR conditions
+const orCount = await client.com.example.post.countRecords({
+  where: {
+    createdAt: { eq: "2025-09-03" },
+  },
+  orWhere: {
+    title: { contains: "typescript" },
+    did: { eq: "did:plc:author" },
+  },
+});
+
 console.log(`Found ${filteredCount.count} matching posts`);
+console.log(`Found ${orCount.count} posts with OR conditions`);
 ```
 
 ### Getting a Single Record
···
 
 ### OR Query Support
 
-You can use OR queries to find records that match any of multiple conditions using the `$or` syntax:
+You can use OR queries to find records that match any of multiple conditions using the separate `orWhere` parameter. This provides clean type safety and autocomplete for field names:
 
 ```typescript
 // Find posts by either user1 OR user2
 const posts = await client.com.example.post.getRecords({
-  where: {
-    "$or": {
-      did: { in: ["did:plc:user1", "did:plc:user2"] }
-    }
+  orWhere: {
+    did: { in: ["did:plc:user1", "did:plc:user2"] }
   }
 });
 
 // Find posts that either have "typescript" in title OR are by a specific user
 const posts = await client.com.example.post.getRecords({
-  where: {
-    "$or": {
-      title: { contains: "typescript" },
-      did: { eq: "did:plc:alice" }
-    }
+  orWhere: {
+    title: { contains: "typescript" },
+    did: { eq: "did:plc:alice" }
   }
 });
 
 // Combining OR with regular AND conditions
 const posts = await client.com.example.post.getRecords({
   where: {
-    createdAt: { eq: "2025-09-03" },  // AND condition
-    "$or": {                          // OR conditions
-      title: { contains: "guide" },
-      did: { eq: "did:plc:user1" }
-    }
+    createdAt: { eq: "2025-09-03" },  // AND conditions
+  },
+  orWhere: {                          // OR conditions
+    title: { contains: "guide" },
+    did: { eq: "did:plc:user1" }
   }
 });
 // SQL: WHERE created_at = '2025-09-03' AND (title LIKE '%guide%' OR did = 'did:plc:user1')
···
 const crossCollectionOrSearch = await client.social.slices.slice.getSliceRecords({
   where: {
     collection: { eq: "com.example.post" },
-    "$or": {
-      title: { contains: "javascript" },
-      tags: { contains: "tutorial" }
-    }
+  },
+  orWhere: {
+    title: { contains: "javascript" },
+    tags: { contains: "tutorial" }
+  }
+});
+
+// You get full autocomplete and type safety for field names in both where and orWhere
+const typedSearch = await client.com.example.post.getRecords({
+  where: {
+    // TypeScript autocompletes valid field names here
+    title: { contains: "react" },
+  },
+  orWhere: {
+    // And also provides autocomplete here
+    description: { contains: "tutorial" },
+    tags: { contains: "guide" },
   }
 });
 ```