feat(api): add stemming dictionaries support

- add `StemmingInterface` with dictionary management methods
- implement dictionary create, retrieve and list operations
- add integration tests for stemming dictionary operations
- register stemming client in the main `Client` struct

Author: tharropoulos

Diff for: typesense/client.go

@@ -48,6 +48,10 @@ func (c *Client) Analytics() AnalyticsInterface {
 	return &analytics{apiClient: c.apiClient}
 }
 
+func (c *Client) Stemming() StemmingInterface {
+	return &stemming{apiClient: c.apiClient}
+}
+
 func (c *Client) Conversations() ConversationsInterface {
 	return &conversations{apiClient: c.apiClient}
 }

Diff for: typesense/stemming.go

@@ -0,0 +1,18 @@
+package typesense
+
+type StemmingInterface interface {
+    Dictionaries() StemmingDictionariesInterface
+    Dictionary(dictionaryId string) StemmingDictionaryInterface
+}
+
+type stemming struct {
+    apiClient APIClientInterface
+}
+
+func (s *stemming) Dictionaries() StemmingDictionariesInterface {
+    return &stemmingDictionaries{apiClient: s.apiClient}
+}
+
+func (s *stemming) Dictionary(dictionaryId string) StemmingDictionaryInterface {
+    return &stemmingDictionary{apiClient: s.apiClient, dictionaryId: dictionaryId}
+}

Diff for: typesense/stemming_dictionaries.go

@@ -0,0 +1,84 @@
+package typesense
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+
+	"github.com/typesense/typesense-go/v3/typesense/api"
+)
+
+type StemmingDictionariesInterface interface {
+    Upsert(ctx context.Context, dictionaryId string, wordRootCombinations []api.StemmingDictionaryWord) ([]*api.StemmingDictionaryWord, error)
+    UpsertJsonl(ctx context.Context, dictionaryId string, body io.Reader) (io.ReadCloser, error)
+    Retrieve(ctx context.Context) (*api.ListStemmingDictionariesResponse, error)
+}
+
+type stemmingDictionaries struct {
+    apiClient APIClientInterface
+}
+
+func (s *stemmingDictionaries) Upsert(ctx context.Context, dictionaryId string, wordRootCombinations []api.StemmingDictionaryWord) ([]*api.StemmingDictionaryWord, error) {
+    var buf bytes.Buffer
+    jsonEncoder := json.NewEncoder(&buf)
+    for _, combo := range wordRootCombinations {
+        if err := jsonEncoder.Encode(combo); err != nil {
+            return nil, err
+        }
+    }
+
+    response, err := s.UpsertJsonl(ctx, dictionaryId, &buf)
+    if err != nil {
+        return nil, err
+    }
+
+    var result []*api.StemmingDictionaryWord
+    jsonDecoder := json.NewDecoder(response)
+    for jsonDecoder.More() {
+        var docResult *api.StemmingDictionaryWord
+        if err := jsonDecoder.Decode(&docResult); err != nil {
+            return result, err
+        }
+        result = append(result, docResult)
+    }
+
+    return result, nil
+}
+
+func (s *stemmingDictionaries) UpsertJsonl(ctx context.Context, dictionaryId string, body io.Reader) (io.ReadCloser, error) {
+    params := &api.ImportStemmingDictionaryParams{
+        Id: dictionaryId,
+    }
+    
+    response, err := s.apiClient.ImportStemmingDictionaryWithBody(ctx,
+        params, "application/octet-stream", body)
+    if err != nil {
+        return nil, err
+    }
+    if response.StatusCode != http.StatusOK {
+        defer response.Body.Close()
+        body, _ := io.ReadAll(response.Body)
+        return nil, &HTTPError{Status: response.StatusCode, Body: body}
+    }
+    return response.Body, nil
+}
+
+func (s *stemmingDictionaries) Retrieve(ctx context.Context) (*api.ListStemmingDictionariesResponse, error) {
+    response, err := s.apiClient.ListStemmingDictionariesWithResponse(ctx)
+    if err != nil {
+        return nil, err
+    }
+    if response.JSON200 == nil {
+        emptySlice := make([]string, 0)
+        return &api.ListStemmingDictionariesResponse{
+            JSON200: &struct {
+                Dictionaries *[]string `json:"dictionaries,omitempty"`
+            }{
+                Dictionaries: &emptySlice,
+            },
+        }, nil
+    }
+    return response, nil
+}

Diff for: typesense/stemming_dictionary.go

@@ -0,0 +1,27 @@
+package typesense
+
+import (
+	"context"
+
+	"github.com/typesense/typesense-go/v3/typesense/api"
+)
+
+type StemmingDictionaryInterface interface {
+    Retrieve(ctx context.Context) (*api.StemmingDictionary, error)
+}
+
+type stemmingDictionary struct {
+    apiClient    APIClientInterface
+    dictionaryId string
+}
+
+func (s *stemmingDictionary) Retrieve(ctx context.Context) (*api.StemmingDictionary, error) {
+    response, err := s.apiClient.GetStemmingDictionaryWithResponse(ctx, s.dictionaryId)
+    if err != nil {
+        return nil, err
+    }
+    if response.JSON200 == nil {
+        return nil, &HTTPError{Status: response.StatusCode(), Body: response.Body}
+    }
+    return response.JSON200, nil
+}

Diff for: typesense/test/stemming_test.go

@@ -0,0 +1,59 @@
+//go:build integration
+// +build integration
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/typesense/typesense-go/v3/typesense/api"
+)
+
+func TestStemmingDictionary(t *testing.T) {
+    dictionaryId := fmt.Sprintf("dictionary_%d", time.Now().UnixNano())
+    words := []api.StemmingDictionaryWord{
+        {
+            Root: "exampleRoot1",
+            Word: "exampleWord1",
+        },
+        {
+            Root: "exampleRoot2",
+            Word: "exampleWord2",
+        },
+    }
+
+    t.Run("Upsert", func(t *testing.T) {
+        result, err := typesenseClient.Stemming().Dictionaries().Upsert(
+            context.Background(),
+            dictionaryId,
+            words,
+        )
+        require.NoError(t, err)
+        require.Len(t, result, len(words))
+    })
+
+    t.Run("Retrieve Single", func(t *testing.T) {
+        result, err := typesenseClient.Stemming().Dictionary(dictionaryId).Retrieve(context.Background())
+        require.NoError(t, err)
+        require.Equal(t, dictionaryId, result.Id)
+        // Convert result.Words to the same type for comparison
+        retrievedWords := make([]api.StemmingDictionaryWord, len(result.Words))
+        for i, w := range result.Words {
+            retrievedWords[i] = api.StemmingDictionaryWord{
+                Root: w.Root,
+                Word: w.Word,
+            }
+        }
+        require.Equal(t, words, retrievedWords)
+    })
+
+    t.Run("List All", func(t *testing.T) {
+        result, err := typesenseClient.Stemming().Dictionaries().Retrieve(context.Background())
+        require.NoError(t, err)
+        require.Contains(t, *result.JSON200.Dictionaries, dictionaryId)
+    })
+}