// Perform a comprehensive search with pagination
let (contacts, totalCount) = try await ContactSearchService.shared.searchContacts(
    query: "john",
    searchFields: [.name, .email, .phone],
    offset: 0,
    limit: 50
)

// Get search service instance
val searchService = ContactSearchService.getInstance(context)

// Perform a comprehensive search with pagination
val result = searchService.searchContacts(
    query = "john",
    fieldType = SearchFieldType.ALL,  // or specific fields like SearchFieldType.NAME
    offset = 0,
    limit = 50
)

result.onSuccess { searchResult ->
    val contacts = searchResult.contacts
    val totalCount = searchResult.totalCount
    // Handle search results
}.onFailure { error ->
    // Handle error
}

// Get search service via contact service
CMContactSearchService *searchService = [[CMContactService sharedInstance] searchService];

// Perform a comprehensive search with pagination
NSError *error = nil;
NSArray<CMContact *> *contacts = [searchService searchContactsWithQuery:@"john"
                                                         searchFields:CMSearchFieldTypeAll
                                                              offset:0
                                                               limit:50
                                                               error:&error];

if (error) {
    // Handle error
} else {
    // Handle search results
}

// Or using completion handler
[searchService searchContactsWithQuery:@"john"
                           fieldType:CMSearchFieldTypeAll
                              offset:0
                               limit:50
                          completion:^(NSArray<CMContact *> *contacts,
                                     NSInteger totalCount,
                                     NSError *_Nullable error) {
    if (error) {
        // Handle error
    } else {
        // Handle search results and total count
    }
}];

// Perform a comprehensive search with pagination
const { contacts, totalCount } = await searchContacts({
    query: "john",
    searchFields: ["name", "email", "phone"],
    offset: 0,
    limit: 50
});

// Quick search optimized for UI interactions
let results = try await ContactSearchService.shared.quickSearch("jo")

// Quick search optimized for UI interactions
val searchService = ContactSearchService.getInstance(context)
val result = searchService.quickSearch("jo")

result.onSuccess { contacts ->
    // Handle quick search results
}.onFailure { error ->
    // Handle error
}

// Quick search optimized for UI interactions
CMContactSearchService *searchService = [[CMContactService sharedInstance] searchService];

// Using direct method
NSError *error = nil;
NSArray<CMContact *> *results = [searchService quickSearchWithQuery:@"jo"
                                                            error:&error];

// Or using completion handler
[searchService quickSearchWithQuery:@"jo"
                       completion:^(NSArray<CMContact *> *contacts,
                                  NSError *_Nullable error) {
    if (error) {
        // Handle error
    } else {
        // Handle quick search results
    }
}];

// Quick search optimized for UI interactions
const results = await quickSearch("jo");

// Search in specific fields
let (contacts, total) = try await ContactSearchService.shared.searchContacts(
    query: "developer",
    searchFields: [.organization, .jobTitle]
)

// Search in specific fields
val searchService = ContactSearchService.getInstance(context)
val result = searchService.searchContacts(
    query = "developer",
    fieldType = SearchFieldType.ORGANIZATION,  // Search in organization field
    offset = 0,
    limit = 20
)

result.onSuccess { searchResult ->
    // Handle search results
}.onFailure { error ->
    // Handle error
}

// Search in specific fields
CMContactSearchService *searchService = [[CMContactService sharedInstance] searchService];

// Using direct method
NSError *error = nil;
NSArray<CMContact *> *contacts = [searchService searchContactsWithQuery:@"developer"
                                                         searchFields:CMSearchFieldTypeOrganization
                                                              offset:0
                                                               limit:20
                                                               error:&error];

// Or using completion handler
[searchService searchContactsWithQuery:@"developer"
                           fieldType:CMSearchFieldTypeOrganization
                              offset:0
                               limit:20
                          completion:^(NSArray<CMContact *> *contacts,
                                     NSInteger totalCount,
                                     NSError *_Nullable error) {
    if (error) {
        // Handle error
    } else {
        // Handle search results
    }
}];

// Search in specific fields
const { contacts, total } = await searchContacts({
    query: "developer",
    searchFields: ["organization", "jobTitle"]
});