@onchaindb/sdk 0.4.0 → 0.4.2

package/src/index.d.ts

@@ -0,0 +1,160 @@
+export { OnChainDBClient } from './client';
+export { BatchOperations, BulkBuilder } from './batch';
+export { QueryBuilder, SelectionBuilder, FieldConditionBuilder, LogicalOperator } from './query-sdk';
+export { DatabaseManager, createDatabaseManager } from './database';
+export type { OnChainDBConfig, StoreRequest, StoreResponse, TransactionStatus, QueryRequest, QueryResponse, TransactionEvents, IndexRequest, IndexResponse, AdvancedQueryRequest, IndexPaymentProof, IndexCostEstimate, StorageCostEstimate } from './types';
+export type { SelectionMap, QueryRequest as RawQuery, QueryResponse as OnChainQueryResponse, QueryValue, Val } from './query-sdk';
+export type { Condition } from './query-sdk';
+export type { Collection, CollectionSchema, FieldDefinition, FieldValidation, Relationship, Index, IndexOptions, IndexStatus, IndexStatistics, CollectionMetadata, DatabaseStats, QueryPlan, BatchOperation, BatchResult } from './database';
+export { OnChainDBError, TransactionError, ValidationError, PaymentRequiredError, PaymentVerificationError } from './types';
+import { OnChainDBConfig } from './types';
+import { OnChainDBClient } from './client';
+export declare function createClient(config: OnChainDBConfig): OnChainDBClient;
+export { AxiosHttpClient, FetchHttpClient, NodeHttpClient, createHttpClient } from './query-sdk';
+export declare const VERSION = "1.0.0";
+/**
+ * OnChainDB TypeScript SDK
+ *
+ * A complete TypeScript SDK for OnChainDB - the decentralized database
+ * built on Celestia blockchain.
+ *
+ * Features:
+ * - ✅ Full type safety with TypeScript
+ * - ✅ Automatic transaction management
+ * - ✅ Real-time confirmation tracking
+ * - ✅ Batch operations with progress tracking
+ * - ✅ Built-in error handling and retries
+ * - ✅ Event-driven architecture
+ * - ✅ Query building and filtering
+ * - ✅ Complete database management (collections, indexes, schemas)
+ * - ✅ Performance monitoring and optimization
+ * - ✅ Schema validation and migration
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { createClient } from '@onchaindb/sdk';
+ *
+ * const db = createClient({
+ *   endpoint: 'http://localhost:9092',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Store data
+ * const result = await db.store({
+ *   data: { message: 'Hello OnChainDB!', user: 'alice' },
+ *   collection: 'messages'
+ * });
+ *
+ * console.log('Stored with ID:', result.id);
+ * console.log('Transaction:', result.transaction_hash);
+ *
+ * // Query data
+ * const messages = await db.query({
+ *   collection: 'messages',
+ *   limit: 10
+ * });
+ *
+ * console.log(`Found ${messages.total} messages`);
+ * ```
+ *
+ * @example Advanced Usage with Events
+ * ```typescript
+ * import { OnChainDBClient } from '@onchaindb/sdk';
+ *
+ * const db = new OnChainDBClient({
+ *   endpoint: 'http://localhost:9092'
+ * });
+ *
+ * // Listen for transaction events
+ * db.on('transaction:pending', (tx) => {
+ *   console.log('Transaction pending:', tx.id);
+ * });
+ *
+ * db.on('transaction:confirmed', (tx) => {
+ *   console.log('Transaction confirmed:', tx.id);
+ * });
+ *
+ * // Store and wait for confirmation
+ * const confirmed = await db.storeAndConfirm({
+ *   data: { important: 'data that needs confirmation' },
+ *   collection: 'critical'
+ * });
+ * ```
+ *
+ * @example Batch Operations
+ * ```typescript
+ * import { OnChainDBClient, BulkBuilder } from '@onchaindb/sdk';
+ *
+ * const db = new OnChainDBClient({ endpoint: 'http://localhost:9092' });
+ * const batch = db.batch();
+ *
+ * // Build bulk operation
+ * const builder = new BulkBuilder()
+ *   .collection('tweets')
+ *   .add({ message: 'Tweet 1', author: 'alice' })
+ *   .add({ message: 'Tweet 2', author: 'bob' })
+ *   .add({ message: 'Tweet 3', author: 'charlie' });
+ *
+ * // Execute with progress tracking
+ * const results = await batch.store(builder.build(), {
+ *   concurrency: 5,
+ *   waitForConfirmation: true,
+ *   onProgress: (completed, total) => {
+ *     console.log(`Progress: ${completed}/${total}`);
+ *   }
+ * });
+ * ```
+ *
+ * @example Database Management
+ * ```typescript
+ * import { createClient } from '@onchaindb/sdk';
+ *
+ * const client = createClient({
+ *   endpoint: 'http://localhost:9092',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Get database manager for an app
+ * const db = client.database('app_12345');
+ *
+ * // Create collections with schemas
+ * await db.createCollection('users', {
+ *   fields: {
+ *     id: { type: 'string', unique: true, required: true },
+ *     name: { type: 'string', required: true },
+ *     email: { type: 'string', unique: true, required: true },
+ *     created_at: { type: 'date', default: () => new Date() }
+ *   }
+ * });
+ *
+ * // Create optimized indexes
+ * await db.createIndex({
+ *   name: 'users_email_index',
+ *   collection: 'users',
+ *   field_name: 'email',
+ *   index_type: 'btree',
+ *   options: { unique: true }
+ * });
+ *
+ * // Monitor performance
+ * const stats = await db.getDatabaseStats();
+ * console.log(`Collections: ${stats.total_collections}, Indexes: ${stats.total_indexes}`);
+ * ```
+ *
+ * @example Error Handling
+ * ```typescript
+ * import { OnChainDBError, TransactionError, ValidationError } from '@onchaindb/sdk';
+ *
+ * try {
+ *   await db.store({ data: { test: 'data' } });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log('Validation failed:', error.message);
+ *   } else if (error instanceof TransactionError) {
+ *     console.log('Transaction failed:', error.transactionId);
+ *   } else if (error instanceof OnChainDBError) {
+ *     console.log('OnChainDB error:', error.code);
+ *   }
+ * }
+ * ```
+ */ 

package/src/index.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.createHttpClient = exports.NodeHttpClient = exports.FetchHttpClient = exports.AxiosHttpClient = exports.PaymentVerificationError = exports.PaymentRequiredError = exports.ValidationError = exports.TransactionError = exports.OnChainDBError = exports.createDatabaseManager = exports.DatabaseManager = exports.LogicalOperator = exports.FieldConditionBuilder = exports.SelectionBuilder = exports.QueryBuilder = exports.BulkBuilder = exports.BatchOperations = exports.OnChainDBClient = void 0;
+exports.createClient = createClient;
+// Main SDK exports
+var client_1 = require("./client");
+Object.defineProperty(exports, "OnChainDBClient", { enumerable: true, get: function () { return client_1.OnChainDBClient; } });
+var batch_1 = require("./batch");
+Object.defineProperty(exports, "BatchOperations", { enumerable: true, get: function () { return batch_1.BatchOperations; } });
+Object.defineProperty(exports, "BulkBuilder", { enumerable: true, get: function () { return batch_1.BulkBuilder; } });
+// Query builder exports from ./query-sdk
+var query_sdk_1 = require("./query-sdk");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return query_sdk_1.QueryBuilder; } });
+Object.defineProperty(exports, "SelectionBuilder", { enumerable: true, get: function () { return query_sdk_1.SelectionBuilder; } });
+Object.defineProperty(exports, "FieldConditionBuilder", { enumerable: true, get: function () { return query_sdk_1.FieldConditionBuilder; } });
+Object.defineProperty(exports, "LogicalOperator", { enumerable: true, get: function () { return query_sdk_1.LogicalOperator; } });
+// Database management exports
+var database_1 = require("./database");
+Object.defineProperty(exports, "DatabaseManager", { enumerable: true, get: function () { return database_1.DatabaseManager; } });
+Object.defineProperty(exports, "createDatabaseManager", { enumerable: true, get: function () { return database_1.createDatabaseManager; } });
+// Error exports
+var types_1 = require("./types");
+Object.defineProperty(exports, "OnChainDBError", { enumerable: true, get: function () { return types_1.OnChainDBError; } });
+Object.defineProperty(exports, "TransactionError", { enumerable: true, get: function () { return types_1.TransactionError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return types_1.ValidationError; } });
+Object.defineProperty(exports, "PaymentRequiredError", { enumerable: true, get: function () { return types_1.PaymentRequiredError; } });
+Object.defineProperty(exports, "PaymentVerificationError", { enumerable: true, get: function () { return types_1.PaymentVerificationError; } });
+const client_2 = require("./client");
+// Convenience factory function
+function createClient(config) {
+    return new client_2.OnChainDBClient(config);
+}
+// Re-export HTTP client utilities from ./query-sdk for advanced usage
+var query_sdk_2 = require("./query-sdk");
+Object.defineProperty(exports, "AxiosHttpClient", { enumerable: true, get: function () { return query_sdk_2.AxiosHttpClient; } });
+Object.defineProperty(exports, "FetchHttpClient", { enumerable: true, get: function () { return query_sdk_2.FetchHttpClient; } });
+Object.defineProperty(exports, "NodeHttpClient", { enumerable: true, get: function () { return query_sdk_2.NodeHttpClient; } });
+Object.defineProperty(exports, "createHttpClient", { enumerable: true, get: function () { return query_sdk_2.createHttpClient; } });
+// SDK version
+exports.VERSION = '1.0.0';
+/**
+ * OnChainDB TypeScript SDK
+ *
+ * A complete TypeScript SDK for OnChainDB - the decentralized database
+ * built on Celestia blockchain.
+ *
+ * Features:
+ * - ✅ Full type safety with TypeScript
+ * - ✅ Automatic transaction management
+ * - ✅ Real-time confirmation tracking
+ * - ✅ Batch operations with progress tracking
+ * - ✅ Built-in error handling and retries
+ * - ✅ Event-driven architecture
+ * - ✅ Query building and filtering
+ * - ✅ Complete database management (collections, indexes, schemas)
+ * - ✅ Performance monitoring and optimization
+ * - ✅ Schema validation and migration
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { createClient } from '@onchaindb/sdk';
+ *
+ * const db = createClient({
+ *   endpoint: 'http://localhost:9092',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Store data
+ * const result = await db.store({
+ *   data: { message: 'Hello OnChainDB!', user: 'alice' },
+ *   collection: 'messages'
+ * });
+ *
+ * console.log('Stored with ID:', result.id);
+ * console.log('Transaction:', result.transaction_hash);
+ *
+ * // Query data
+ * const messages = await db.query({
+ *   collection: 'messages',
+ *   limit: 10
+ * });
+ *
+ * console.log(`Found ${messages.total} messages`);
+ * ```
+ *
+ * @example Advanced Usage with Events
+ * ```typescript
+ * import { OnChainDBClient } from '@onchaindb/sdk';
+ *
+ * const db = new OnChainDBClient({
+ *   endpoint: 'http://localhost:9092'
+ * });
+ *
+ * // Listen for transaction events
+ * db.on('transaction:pending', (tx) => {
+ *   console.log('Transaction pending:', tx.id);
+ * });
+ *
+ * db.on('transaction:confirmed', (tx) => {
+ *   console.log('Transaction confirmed:', tx.id);
+ * });
+ *
+ * // Store and wait for confirmation
+ * const confirmed = await db.storeAndConfirm({
+ *   data: { important: 'data that needs confirmation' },
+ *   collection: 'critical'
+ * });
+ * ```
+ *
+ * @example Batch Operations
+ * ```typescript
+ * import { OnChainDBClient, BulkBuilder } from '@onchaindb/sdk';
+ *
+ * const db = new OnChainDBClient({ endpoint: 'http://localhost:9092' });
+ * const batch = db.batch();
+ *
+ * // Build bulk operation
+ * const builder = new BulkBuilder()
+ *   .collection('tweets')
+ *   .add({ message: 'Tweet 1', author: 'alice' })
+ *   .add({ message: 'Tweet 2', author: 'bob' })
+ *   .add({ message: 'Tweet 3', author: 'charlie' });
+ *
+ * // Execute with progress tracking
+ * const results = await batch.store(builder.build(), {
+ *   concurrency: 5,
+ *   waitForConfirmation: true,
+ *   onProgress: (completed, total) => {
+ *     console.log(`Progress: ${completed}/${total}`);
+ *   }
+ * });
+ * ```
+ *
+ * @example Database Management
+ * ```typescript
+ * import { createClient } from '@onchaindb/sdk';
+ *
+ * const client = createClient({
+ *   endpoint: 'http://localhost:9092',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Get database manager for an app
+ * const db = client.database('app_12345');
+ *
+ * // Create collections with schemas
+ * await db.createCollection('users', {
+ *   fields: {
+ *     id: { type: 'string', unique: true, required: true },
+ *     name: { type: 'string', required: true },
+ *     email: { type: 'string', unique: true, required: true },
+ *     created_at: { type: 'date', default: () => new Date() }
+ *   }
+ * });
+ *
+ * // Create optimized indexes
+ * await db.createIndex({
+ *   name: 'users_email_index',
+ *   collection: 'users',
+ *   field_name: 'email',
+ *   index_type: 'btree',
+ *   options: { unique: true }
+ * });
+ *
+ * // Monitor performance
+ * const stats = await db.getDatabaseStats();
+ * console.log(`Collections: ${stats.total_collections}, Indexes: ${stats.total_indexes}`);
+ * ```
+ *
+ * @example Error Handling
+ * ```typescript
+ * import { OnChainDBError, TransactionError, ValidationError } from '@onchaindb/sdk';
+ *
+ * try {
+ *   await db.store({ data: { test: 'data' } });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log('Validation failed:', error.message);
+ *   } else if (error instanceof TransactionError) {
+ *     console.log('Transaction failed:', error.transactionId);
+ *   } else if (error instanceof OnChainDBError) {
+ *     console.log('OnChainDB error:', error.code);
+ *   }
+ * }
+ * ```
+ */ 

package/src/index.ts

@@ -0,0 +1,253 @@
+// Main SDK exports
+export {OnChainDBClient} from './client';
+export {BatchOperations, BulkBuilder} from './batch';
+
+// Query builder exports from ./query-sdk
+export {QueryBuilder, SelectionBuilder, FieldConditionBuilder, LogicalOperator, ConditionBuilder, JoinBuilder, OnChainDB} from './query-sdk';
+
+// Database management exports
+export {DatabaseManager, createDatabaseManager} from './database';
+
+// Type exports
+export type {
+    OnChainDBConfig,
+    StoreRequest,
+    StoreResponse,
+    TransactionStatus,
+    QueryRequest,
+    QueryResponse,
+    TransactionEvents,
+    IndexRequest,
+    IndexResponse,
+    RelationRequest,
+    RelationResponse,
+    AdvancedQueryRequest,
+    UploadBlobRequest,
+    UploadBlobResponse,
+    RetrieveBlobRequest,
+    BlobMetadata,
+    PricingQuoteRequest,
+    PricingQuoteResponse,
+    SimpleCollectionSchema,
+    SimpleFieldDefinition,
+    CreateCollectionResult,
+    SyncCollectionResult,
+    BaseDocument,
+    ShardingStrategy,
+    ShardKey,
+    SimpleCollectionSchemaWithSharding
+} from './types';
+
+// Query type exports from ./query-sdk
+export type {
+    SelectionMap,
+    QueryRequest as RawQuery,
+    QueryResponse as OnChainQueryResponse,
+    QueryValue,
+    Val
+} from './query-sdk';
+
+// Re-export operator types from ./query-sdk
+export type {Condition} from './query-sdk';
+
+// x402 payment types
+export type {
+    X402Quote,
+    X402PaymentRequirement,
+    X402PaymentResult,
+    ChainType,
+    PaymentMethod
+} from './x402';
+
+// Database management type exports
+export type {
+    Collection,
+    CollectionSchema,
+    FieldDefinition,
+    FieldValidation,
+    Relationship,
+    Index,
+    IndexOptions,
+    IndexStatus,
+    IndexStatistics,
+    PriceConfig,
+    CollectionMetadata,
+    DatabaseStats,
+    QueryPlan,
+    BatchOperation,
+    BatchResult,
+    MaterializedView,
+    ViewInfo,
+    ListViewsResponse
+} from './database';
+
+// Error exports
+export {
+    OnChainDBError,
+    TransactionError,
+    ValidationError,
+    PaymentRequiredError,
+    PaymentVerificationError
+} from './types';
+
+// Import types for factory function
+import {OnChainDBConfig} from './types';
+import {OnChainDBClient} from './client';
+
+// Convenience factory function
+export function createClient(config: OnChainDBConfig): OnChainDBClient {
+    return new OnChainDBClient(config);
+}
+
+// Re-export HTTP client utilities from ./query-sdk for advanced usage
+export {AxiosHttpClient, FetchHttpClient, NodeHttpClient, createHttpClient} from './query-sdk';
+
+// SDK version
+export const VERSION = '1.0.0';
+
+/**
+ * OnChainDB TypeScript SDK
+ *
+ * A complete TypeScript SDK for OnChainDB - the decentralized database
+ * built on Celestia blockchain.
+ *
+ * Features:
+ * - ✅ Full type safety with TypeScript
+ * - ✅ Automatic transaction management
+ * - ✅ Real-time confirmation tracking
+ * - ✅ Batch operations with progress tracking
+ * - ✅ Built-in error handling and retries
+ * - ✅ Event-driven architecture
+ * - ✅ Query building and filtering
+ * - ✅ Complete database management (collections, indexes, schemas)
+ * - ✅ Performance monitoring and optimization
+ * - ✅ Schema validation and migration
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { createClient } from '@onchaindb/sdk';
+ *
+ * const db = createClient({
+ *   endpoint: 'http://localhost:9092',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Store data
+ * const result = await db.store({
+ *   data: { message: 'Hello OnChainDB!', user: 'alice' },
+ *   collection: 'messages'
+ * });
+ *
+ * console.log('Stored with ID:', result.id);
+ * console.log('Transaction:', result.transaction_hash);
+ *
+ * // Query data
+ * const messages = await db.query({ 
+ *   collection: 'messages',
+ *   limit: 10 
+ * });
+ *
+ * console.log(`Found ${messages.total} messages`);
+ * ```
+ *
+ * @example Advanced Usage with Events
+ * ```typescript
+ * import { OnChainDBClient } from '@onchaindb/sdk';
+ *
+ * const db = new OnChainDBClient({
+ *   endpoint: 'http://localhost:9092'
+ * });
+ *
+ * // Listen for transaction events
+ * db.on('transaction:pending', (tx) => {
+ *   console.log('Transaction pending:', tx.id);
+ * });
+ *
+ * db.on('transaction:confirmed', (tx) => {
+ *   console.log('Transaction confirmed:', tx.id);
+ * });
+ *
+ * // Store and wait for confirmation
+ * const confirmed = await db.storeAndConfirm({
+ *   data: { important: 'data that needs confirmation' },
+ *   collection: 'critical'
+ * });
+ * ```
+ *
+ * @example Batch Operations
+ * ```typescript
+ * import { OnChainDBClient, BulkBuilder } from '@onchaindb/sdk';
+ *
+ * const db = new OnChainDBClient({ endpoint: 'http://localhost:9092' });
+ * const batch = db.batch();
+ *
+ * // Build bulk operation
+ * const builder = new BulkBuilder()
+ *   .collection('tweets')
+ *   .add({ message: 'Tweet 1', author: 'alice' })
+ *   .add({ message: 'Tweet 2', author: 'bob' })
+ *   .add({ message: 'Tweet 3', author: 'charlie' });
+ *
+ * // Execute with progress tracking
+ * const results = await batch.store(builder.build(), {
+ *   concurrency: 5,
+ *   waitForConfirmation: true,
+ *   onProgress: (completed, total) => {
+ *     console.log(`Progress: ${completed}/${total}`);
+ *   }
+ * });
+ * ```
+ *
+ * @example Database Management
+ * ```typescript
+ * import { createClient } from '@onchaindb/sdk';
+ *
+ * const client = createClient({
+ *   endpoint: 'http://localhost:9092',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Get database manager for an app
+ * const db = client.database('app_12345');
+ *
+ * // Create collections with schemas
+ * await db.createCollection('users', {
+ *   fields: {
+ *     id: { type: 'string', unique: true, required: true },
+ *     name: { type: 'string', required: true },
+ *     email: { type: 'string', unique: true, required: true },
+ *     created_at: { type: 'date', default: () => new Date() }
+ *   }
+ * });
+ *
+ * // Create optimized indexes
+ * await db.createIndex({
+ *   name: 'users_email_index',
+ *   collection: 'users',
+ *   field_name: 'email',
+ *   index_type: 'btree',
+ *   options: { unique: true }
+ * });
+ *
+ * // Monitor performance
+ * const stats = await db.getDatabaseStats();
+ * console.log(`Collections: ${stats.total_collections}, Indexes: ${stats.total_indexes}`);
+ * ```
+ *
+ * @example Error Handling
+ * ```typescript
+ * import { OnChainDBError, TransactionError, ValidationError } from '@onchaindb/sdk';
+ *
+ * try {
+ *   await db.store({ data: { test: 'data' } });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log('Validation failed:', error.message);
+ *   } else if (error instanceof TransactionError) {
+ *     console.log('Transaction failed:', error.transactionId);
+ *   } else if (error instanceof OnChainDBError) {
+ *     console.log('OnChainDB error:', error.code);
+ *   }
+ * }
+ * ```
+ */

package/src/query-sdk/ConditionBuilder.ts

@@ -0,0 +1,103 @@
+import { LogicalOperator, FieldConditionBuilder } from './operators';
+import { NestedConditionBuilder } from './NestedBuilders';
+
+// Builder for creating complex conditions with logical operators
+export class ConditionBuilder {
+  private conditions: LogicalOperator[] = [];
+  private currentOperator?: 'and' | 'or' | 'not';
+
+  constructor() {}
+
+  static new(): ConditionBuilder {
+    return new ConditionBuilder();
+  }
+
+  // Create a field condition builder
+  field(fieldName: string): FieldConditionBuilder {
+    return new FieldConditionBuilder(fieldName);
+  }
+
+  // Create a nested field condition with fluent API (like Rust SDK)
+  nested(fieldName: string, builderFn: (builder: NestedConditionBuilder) => LogicalOperator): LogicalOperator {
+    const nestedBuilder = new NestedConditionBuilder(fieldName);
+    return builderFn(nestedBuilder);
+  }
+
+  // Add an AND operator context
+  and(): ConditionBuilder {
+    this.currentOperator = 'and';
+    return this;
+  }
+
+  // Add an OR operator context
+  or(): ConditionBuilder {
+    this.currentOperator = 'or';
+    return this;
+  }
+
+  // Add a NOT operator context
+  not(): ConditionBuilder {
+    this.currentOperator = 'not';
+    return this;
+  }
+
+  // Group conditions with AND logic
+  andGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
+    const nestedBuilder = new ConditionBuilder();
+    const conditions = builderFn(nestedBuilder);
+    return LogicalOperator.And(conditions);
+  }
+
+  // Group conditions with OR logic
+  orGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
+    const nestedBuilder = new ConditionBuilder();
+    const conditions = builderFn(nestedBuilder);
+    return LogicalOperator.Or(conditions);
+  }
+
+  // Group conditions with NOT logic
+  notGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
+    const nestedBuilder = new ConditionBuilder();
+    const conditions = builderFn(nestedBuilder);
+    return LogicalOperator.Not(conditions);
+  }
+
+  // Add a condition to the current builder
+  addCondition(condition: LogicalOperator): ConditionBuilder {
+    this.conditions.push(condition);
+    return this;
+  }
+
+  // Build and return all conditions
+  build(): LogicalOperator[] {
+    return [...this.conditions];
+  }
+
+  // Build as a single logical operator (combines all conditions with AND by default)
+  buildSingle(): LogicalOperator {
+    if (this.conditions.length === 0) {
+      throw new Error('No conditions to build');
+    }
+    if (this.conditions.length === 1) {
+      return this.conditions[0];
+    }
+    return LogicalOperator.And(this.conditions);
+  }
+
+  // Clear all conditions
+  clear(): ConditionBuilder {
+    this.conditions = [];
+    this.currentOperator = undefined;
+    return this;
+  }
+
+  // Check if any conditions have been added
+  isEmpty(): boolean {
+    return this.conditions.length === 0;
+  }
+
+  // Get the number of conditions
+  getConditionCount(): number {
+    return this.conditions.length;
+  }
+}

package/src/query-sdk/FieldConditionBuilder.ts

@@ -0,0 +1,2 @@
+// Re-export from operators for convenience
+export { FieldConditionBuilder } from './operators';