typesense

type APIClientInterface interface {
	api.ClientWithResponsesInterface
	api.ClientInterface
}

type AliasInterface interface {
	Retrieve() (*api.CollectionAlias, error)
	Delete() (*api.CollectionAlias, error)
}

type AliasesInterface interface {
	Upsert(aliasName string, aliasSchema *api.CollectionAliasSchema) (*api.CollectionAlias, error)
	Retrieve() ([]*api.CollectionAlias, error)
}

type Client struct {
	MultiSearch MultiSearchInterface
	// contains filtered or unexported fields
}

type ClientConfig struct {
	ServerURL                   string
	APIKey                      string
	ConnectionTimeout           time.Duration
	CircuitBreakerName          string
	CircuitBreakerMaxRequests   uint32
	CircuitBreakerInterval      time.Duration
	CircuitBreakerTimeout       time.Duration
	CircuitBreakerReadyToTrip   circuit.GoBreakerReadyToTripFunc
	CircuitBreakerOnStateChange circuit.GoBreakerOnStateChangeFunc
}

type ClientOption func(*Client)

type CollectionInterface interface {
	Retrieve() (*api.CollectionResponse, error)
	Delete() (*api.CollectionResponse, error)
	Documents() DocumentsInterface
	Document(documentID string) DocumentInterface
	Overrides() OverridesInterface
	Override(overrideID string) OverrideInterface
	Synonyms() SynonymsInterface
	Synonym(synonymID string) SynonymInterface
	Update(schema *api.CollectionUpdateSchema) (*api.CollectionUpdateSchema, error)
}

type CollectionsInterface interface {
	Create(schema *api.CollectionSchema) (*api.CollectionResponse, error)
	Retrieve() ([]*api.CollectionResponse, error)
}

type DocumentInterface interface {
	Retrieve() (map[string]interface{}, error)
	Update(document interface{}) (map[string]interface{}, error)
	Delete() (map[string]interface{}, error)
}

type DocumentsInterface interface {
	// Create returns indexed document
	Create(document interface{}) (map[string]interface{}, error)
	// Update updates documents matching the filter_by condition
	Update(updateFields interface{}, params *api.UpdateDocumentsParams) (int, error)
	// Upsert returns indexed/updated document
	Upsert(document interface{}) (map[string]interface{}, error)
	// Delete returns number of deleted documents
	Delete(filter *api.DeleteDocumentsParams) (int, error)
	// Search performs document search in collection
	Search(params *api.SearchCollectionParams) (*api.SearchResult, error)
	// Export returns all documents from index in jsonl format
	Export() (io.ReadCloser, error)
	// Import returns json array. Each item of the response indicates
	// the result of each document present in the request body (in the same order).
	Import(documents []interface{}, params *api.ImportDocumentsParams) ([]*api.ImportDocumentResponse, error)
	// ImportJsonl accepts documents and returns result in jsonl format. Each line of the
	// response indicates the result of each document present in the
	// request body (in the same order).
	ImportJsonl(body io.Reader, params *api.ImportDocumentsParams) (io.ReadCloser, error)
}

type HTTPError struct {
	Status int
	Body   []byte
}

type KeyInterface interface {
	Retrieve() (*api.ApiKey, error)
	Delete() (*api.ApiKey, error)
}

type KeysInterface interface {
	Create(key *api.ApiKeySchema) (*api.ApiKey, error)
	Retrieve() ([]*api.ApiKey, error)
}

type MultiSearchInterface interface {
	Perform(searchParams *api.MultiSearchParams, commonSearchParams api.MultiSearchSearchesParameter) (*api.MultiSearchResult, error)
	PerformWithContentType(searchParams *api.MultiSearchParams, commonSearchParams api.MultiSearchSearchesParameter, contentType string) (*api.MultiSearchResponse, error)
}

type OperationsInterface interface {
	Snapshot(snapshotPath string) (bool, error)
	Vote() (bool, error)
}

type OverrideInterface interface {
	Retrieve() (*api.SearchOverride, error)
	Delete() (*api.SearchOverride, error)
}

type OverridesInterface interface {
	Upsert(overrideID string, overrideSchema *api.SearchOverrideSchema) (*api.SearchOverride, error)
	Retrieve() ([]*api.SearchOverride, error)
}

type SynonymInterface interface {
	// Retrieve a single search synonym
	Retrieve() (*api.SearchSynonym, error)
	// Delete a synonym associated with a collection
	Delete() (*api.SearchSynonym, error)
}

type SynonymsInterface interface {
	// Create or update a synonym
	Upsert(synonymID string, synonymSchema *api.SearchSynonymSchema) (*api.SearchSynonym, error)
	// List all collection synonyms
	Retrieve() ([]*api.SearchSynonym, error)
}