feat: add missing endpoitn implementation

client/cards.go

@@ -15,7 +15,7 @@ func (s *tcgDexClient) GetCard(ctx context.Context, id string) (*models.Card, er
 		return nil, err
 	}
 
-	card, err := doRequest[*models.Card](s.httpClient, request)
+	card, err := doRequest[models.Card](s.httpClient, request)
 	if err != nil {
 		return nil, err
 	}
@@ -25,13 +25,13 @@ func (s *tcgDexClient) GetCard(ctx context.Context, id string) (*models.Card, er
 
 // Cards retrieves all cards.
 // This function returns a list of all cards available in the Pokémon TCG database.
-func (s *tcgDexClient) Cards(ctx context.Context) ([]*models.Card, error) {
+func (s *tcgDexClient) Cards(ctx context.Context) ([]models.Card, error) {
 	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/cards", nil)
 	if err != nil {
 		return nil, err
 	}
 
-	cards, err := doRequest[[]*models.Card](s.httpClient, request)
+	cards, err := doRequestSlice[models.Card](s.httpClient, request)
 	if err != nil {
 		return nil, err
 	}

client/cards_test.go

@@ -1,27 +1,47 @@
 package client
 
 import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 
+	"github.com/kratisto/tcgdex-golang/models"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGetCardByID(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name     string
 		cardID   string
-		wantErr  bool
-		wantCard *Card
+		wantErr  error
+		wantCard *models.Card
 	}{
-		{"valid card", "xy1-1", false, &Card{ID: "xy1-1"}},
-		{"invalid card", "invalid-id", true, nil},
+		{"valid card", "xy1-1", nil, &models.Card{ID: "xy1-1"}},
+		{"invalid card", "invalid-id", ErrNotFound, nil},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			card, err := GetCardByID(tt.cardID)
+			t.Parallel()
 
-			require.ErrorIs(t, err, ErrNotFound)
+			// Setup fake server
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.URL.Path == "/cards/xy1-1" {
+					w.Header().Set("Content-Type", "application/json")
+					json.NewEncoder(w).Encode(tt.wantCard)
+					return
+				}
+				http.Error(w, "", http.StatusNotFound)
+			}))
+			defer server.Close()
+
+			client := NewClientWithCustomHTTPClient(server.URL, "en", server.Client())
+			card, err := client.GetCard(t.Context(), tt.cardID)
+
+			require.ErrorIs(t, err, tt.wantErr)
 			require.Equal(t, tt.wantCard, card, "expected card: %v, got: %v for cardID %v", tt.wantCard, card, tt.cardID)
 		})
 	}

client/categories.go

@@ -0,0 +1,45 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// Categories retrieves all categories.
+func (s *tcgDexClient) Categories(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/categories", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByCategory retrieves all cards for a given category, with optional filters.
+func (s *tcgDexClient) GetCardsByCategory(ctx context.Context, category string, params *FilterParams) ([]models.Card, error) {
+	endpoint := s.baseURL + "/categories/" + category
+	urlParams := url.Values{}
+	if params != nil {
+		if params.Sort != "" {
+			urlParams.Add("sort", params.Sort)
+		}
+		if params.Page > 0 {
+			urlParams.Add("page", fmt.Sprintf("%d", params.Page))
+		}
+		if params.PageSize > 0 {
+			urlParams.Add("pageSize", fmt.Sprintf("%d", params.PageSize))
+		}
+	}
+	if len(urlParams) > 0 {
+		endpoint += "?" + urlParams.Encode()
+	}
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/client.go

@@ -4,6 +4,7 @@ package client
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"net/http"
 
 	"github.com/kratisto/tcgdex-golang/models"
@@ -14,28 +15,109 @@ const (
 	defaultLanguage = "en"
 )
 
+var (
+	ErrNotFound = errors.New("not found")
+)
+
+// FilterParams regroupe les paramètres de filtre pour les requêtes de ressources
+type FilterParams struct {
+	Sort     string
+	Page     int
+	PageSize int
+}
+
 // TCGDexClient is the interface for interacting with the Pokémon TCG database.
 type TCGDexClient interface {
 	CardsClient
 	SeriesClient
 	SetsClient
+	CategoriesClient
+	HPClient
+	IllustratorsClient
+	RaritiesClient
+	RetreatsClient
+	TypesClient
+	DexIDsClient
+	EnergyTypesClient
+	RegulationMarksClient
+	StagesClient
+}
+
+// CategoriesClient is the interface for category-related operations.
+type CategoriesClient interface {
+	Categories(ctx context.Context) ([]string, error)
+	GetCardsByCategory(ctx context.Context, category string, params *FilterParams) ([]models.Card, error)
+}
+
+// HPClient is the interface for HP-related operations.
+type HPClient interface {
+	HPs(ctx context.Context) ([]string, error)
+	GetCardsByHP(ctx context.Context, hp string, params *FilterParams) ([]models.Card, error)
+}
+
+// IllustratorsClient is the interface for illustrator-related operations.
+type IllustratorsClient interface {
+	Illustrators(ctx context.Context) ([]string, error)
+	GetCardsByIllustrator(ctx context.Context, illustrator string) ([]models.Card, error)
+}
+
+// RaritiesClient is the interface for rarity-related operations.
+type RaritiesClient interface {
+	Rarities(ctx context.Context) ([]string, error)
+	GetCardsByRarity(ctx context.Context, rarity string, params *FilterParams) ([]models.Card, error)
+}
+
+// RetreatsClient is the interface for retreat-related operations.
+type RetreatsClient interface {
+	Retreats(ctx context.Context) ([]string, error)
+	GetCardsByRetreat(ctx context.Context, retreat string, params *FilterParams) ([]models.Card, error)
+}
+
+// TypesClient is the interface for type-related operations.
+type TypesClient interface {
+	Types(ctx context.Context) ([]string, error)
+	GetCardsByType(ctx context.Context, typ string, params *FilterParams) ([]models.Card, error)
+}
+
+// DexIDsClient is the interface for dexid-related operations.
+type DexIDsClient interface {
+	DexIDs(ctx context.Context) ([]int, error)
+	GetCardsByDexID(ctx context.Context, dexID int) ([]models.Card, error)
+}
+
+// EnergyTypesClient is the interface for energy type-related operations.
+type EnergyTypesClient interface {
+	EnergyTypes(ctx context.Context) ([]string, error)
+	GetCardsByEnergyType(ctx context.Context, energyType string) ([]models.Card, error)
+}
+
+// RegulationMarksClient is the interface for regulation mark-related operations.
+type RegulationMarksClient interface {
+	RegulationMarks(ctx context.Context) ([]string, error)
+	GetCardsByRegulationMark(ctx context.Context, regulationMark string) ([]models.Card, error)
+}
+
+// StagesClient is the interface for stage-related operations.
+type StagesClient interface {
+	Stages(ctx context.Context) ([]string, error)
+	GetCardsByStage(ctx context.Context, stage string) ([]models.Card, error)
 }
 
 // CardsClient is the interface for card-related operations.
 type CardsClient interface {
 	GetCard(ctx context.Context, id string) (*models.Card, error)
-	Cards(ctx context.Context) ([]*models.Card, error)
+	Cards(ctx context.Context) ([]models.Card, error)
 }
 
 // SeriesClient is the interface for series-related operations.
 type SeriesClient interface {
-	Series(ctx context.Context) ([]*models.Serie, error)
+	Series(ctx context.Context) ([]models.Serie, error)
 	GetSerie(ctx context.Context, seriesID string) (*models.Serie, error)
 }
 
 // SetsClient is the interface for set-related operations.
 type SetsClient interface {
-	Sets(ctx context.Context) ([]*models.Set, error)
+	Sets(ctx context.Context) ([]models.Set, error)
 	GetSet(ctx context.Context, setID string) (*models.Set, error)
 	GetCardOfSet(ctx context.Context, setID string, cardID string) (*models.Card, error)
 }
@@ -69,12 +151,12 @@ func NewClientWithCustomHTTPClient(url string, language string, client *http.Cli
 	}
 }
 
-func doRequest[T any](client *http.Client, request *http.Request) (T, error) {
+func doRequest[T any](client *http.Client, request *http.Request) (*T, error) {
 	var result T
 
 	resp, err := client.Do(request)
 	if err != nil {
-		return result, err
+		return nil, err
 	}
 
 	defer func() {
@@ -84,11 +166,50 @@ func doRequest[T any](client *http.Client, request *http.Request) (T, error) {
 		}
 	}()
 
+	if resp.StatusCode >= 400 && resp.StatusCode < 500 {
+		if resp.StatusCode == http.StatusNotFound {
+			return nil, ErrNotFound
+		}
+		return nil, errors.New(http.StatusText(resp.StatusCode))
+	}
+
 	jsonDecoder := json.NewDecoder(resp.Body)
 
 	err = jsonDecoder.Decode(&result)
 	if err != nil {
-		return result, err
+		return nil, err
+	}
+
+	return &result, nil
+}
+
+func doRequestSlice[T any](client *http.Client, request *http.Request) ([]T, error) {
+	var result []T
+
+	resp, err := client.Do(request)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		err := resp.Body.Close()
+		if err != nil {
+			panic(err)
+		}
+	}()
+
+	if resp.StatusCode >= 400 && resp.StatusCode < 500 {
+		if resp.StatusCode == http.StatusNotFound {
+			return nil, ErrNotFound
+		}
+		return nil, errors.New(http.StatusText(resp.StatusCode))
+	}
+
+	jsonDecoder := json.NewDecoder(resp.Body)
+
+	err = jsonDecoder.Decode(&result)
+	if err != nil {
+		return nil, err
 	}
 
 	return result, nil

client/client_builder.go

@@ -1,61 +0,0 @@
-package client
-
-import "net/http"
-
-// Builder is a builder for creating a TCGDexClient with customizable options.
-type Builder struct {
-	language   *string
-	baseURL    *string
-	httpClient *http.Client
-}
-
-// NewBuilder creates a new Builder instance.
-// This allows for fluent configuration of the TCGDexClient.
-func NewBuilder() *Builder {
-	return &Builder{}
-}
-
-// Language sets the language for the TCGDexClient.
-func (b *Builder) Language(language string) *Builder {
-	b.language = &language
-
-	return b
-}
-
-// BaseURL sets the base URL for the TCGDexClient.
-func (b *Builder) BaseURL(baseURL string) *Builder {
-	b.baseURL = &baseURL
-
-	return b
-}
-
-// HTTPClient sets the custom HTTP client for the TCGDexClient.
-func (b *Builder) HTTPClient(client *http.Client) *Builder {
-	b.httpClient = client
-
-	return b
-}
-
-// Builder constructs the TCGDexClient with the specified options.
-func (b *Builder) Builder() TCGDexClient {
-	httpClient := b.httpClient
-	if httpClient == nil {
-		httpClient = http.DefaultClient
-	}
-
-	language := b.language
-	if language == nil {
-		language = ptr(defaultLanguage)
-	}
-
-	baseURL := b.baseURL
-	if baseURL == nil {
-		baseURL = ptr(defaultURL)
-	}
-
-	return NewClientWithCustomHTTPClient(*baseURL, *language, httpClient)
-}
-
-func ptr[T any](s T) *T {
-	return &s
-}

client/dexids.go

@@ -0,0 +1,29 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// DexIDs retrieves all Pokedex IDs.
+func (s *tcgDexClient) DexIDs(ctx context.Context) ([]int, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/dex-ids", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[int](s.httpClient, request)
+}
+
+// GetCardsByDexID retrieves all cards for a given Pokedex ID.
+func (s *tcgDexClient) GetCardsByDexID(ctx context.Context, dexID int) ([]models.Card, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/dex-ids/"+fmt.Sprint(dexID), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/energytypes.go

@@ -0,0 +1,28 @@
+package client
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// EnergyTypes retrieves all energy types.
+func (s *tcgDexClient) EnergyTypes(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/energy-types", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByEnergyType retrieves all cards for a given energy type.
+func (s *tcgDexClient) GetCardsByEnergyType(ctx context.Context, energyType string) ([]models.Card, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/energy-types/"+energyType, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/hp.go

@@ -0,0 +1,45 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// HPs retrieves all HP values.
+func (s *tcgDexClient) HPs(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/hp", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByHP retrieves all cards for a given HP value.
+func (s *tcgDexClient) GetCardsByHP(ctx context.Context, hp string, params *FilterParams) ([]models.Card, error) {
+	endpoint := s.baseURL + "/hp/" + hp
+	urlParams := url.Values{}
+	if params != nil {
+		if params.Sort != "" {
+			urlParams.Add("sort", params.Sort)
+		}
+		if params.Page > 0 {
+			urlParams.Add("page", fmt.Sprintf("%d", params.Page))
+		}
+		if params.PageSize > 0 {
+			urlParams.Add("pageSize", fmt.Sprintf("%d", params.PageSize))
+		}
+	}
+	if len(urlParams) > 0 {
+		endpoint += "?" + urlParams.Encode()
+	}
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/illustrators.go

@@ -0,0 +1,28 @@
+package client
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// Illustrators retrieves all illustrators.
+func (s *tcgDexClient) Illustrators(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/illustrators", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByIllustrator retrieves all cards for a given illustrator.
+func (s *tcgDexClient) GetCardsByIllustrator(ctx context.Context, illustrator string) ([]models.Card, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/illustrators/"+illustrator, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/rarities.go

@@ -0,0 +1,46 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// Rarities retrieves all rarities.
+func (s *tcgDexClient) Rarities(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/rarities", nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByRarity retrieves all cards for a given rarity.
+func (s *tcgDexClient) GetCardsByRarity(ctx context.Context, rarity string, params *FilterParams) ([]models.Card, error) {
+	endpoint := s.baseURL + "/rarities/" + rarity
+	urlParams := url.Values{}
+	if params != nil {
+		if params.Sort != "" {
+			urlParams.Add("sort", params.Sort)
+		}
+		if params.Page > 0 {
+			urlParams.Add("page", fmt.Sprintf("%d", params.Page))
+		}
+		if params.PageSize > 0 {
+			urlParams.Add("pageSize", fmt.Sprintf("%d", params.PageSize))
+		}
+	}
+
+	if len(urlParams) > 0 {
+		endpoint += "?" + urlParams.Encode()
+	}
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/regulationmarks.go

@@ -0,0 +1,28 @@
+package client
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// RegulationMarks retrieves all regulation marks.
+func (s *tcgDexClient) RegulationMarks(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/regulation-marks", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByRegulationMark retrieves all cards for a given regulation mark.
+func (s *tcgDexClient) GetCardsByRegulationMark(ctx context.Context, regulationMark string) ([]models.Card, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/regulation-marks/"+regulationMark, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/retreats.go

@@ -0,0 +1,45 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// Retreats retrieves all retreat costs.
+func (s *tcgDexClient) Retreats(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/retreats", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByRetreat retrieves all cards for a given retreat cost.
+func (s *tcgDexClient) GetCardsByRetreat(ctx context.Context, retreat string, params *FilterParams) ([]models.Card, error) {
+	endpoint := s.baseURL + "/retreats/" + retreat
+	urlParams := url.Values{}
+	if params != nil {
+		if params.Sort != "" {
+			urlParams.Add("sort", params.Sort)
+		}
+		if params.Page > 0 {
+			urlParams.Add("page", fmt.Sprintf("%d", params.Page))
+		}
+		if params.PageSize > 0 {
+			urlParams.Add("pageSize", fmt.Sprintf("%d", params.PageSize))
+		}
+	}
+	if len(urlParams) > 0 {
+		endpoint += "?" + urlParams.Encode()
+	}
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/series.go

@@ -9,13 +9,13 @@ import (
 
 // Series retrieves all series.
 // This function returns a list of all series available in the Pokémon TCG database.
-func (s *tcgDexClient) Series(ctx context.Context) ([]*models.Serie, error) {
+func (s *tcgDexClient) Series(ctx context.Context) ([]models.Serie, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/series", nil)
 	if err != nil {
 		return nil, err
 	}
 
-	series, err := doRequest[[]*models.Serie](s.httpClient, req)
+	series, err := doRequestSlice[models.Serie](s.httpClient, req)
 	if err != nil {
 		return nil, err
 	}
@@ -31,7 +31,7 @@ func (s *tcgDexClient) GetSerie(ctx context.Context, seriesID string) (*models.S
 		return nil, err
 	}
 
-	serie, err := doRequest[*models.Serie](s.httpClient, req)
+	serie, err := doRequest[models.Serie](s.httpClient, req)
 	if err != nil {
 		return nil, err
 	}

client/series_test.go

@@ -1,28 +0,0 @@
-package client
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestGetSeriesByID(t *testing.T) {
-	tests := []struct {
-		name       string
-		seriesID   string
-		wantErr    bool
-		wantSeries *Series
-	}{
-		{"valid series", "xy", false, &Series{ID: "xy"}},
-		{"invalid series", "invalid-id", true, nil},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			series, err := GetSeriesByID(tt.seriesID)
-
-			require.ErrorIs(t, err, ErrNotFound)
-			require.Equal(t, tt.wantSeries, series, "expected series: %v, got: %v for seriesID %v", tt.wantSeries, series, tt.seriesID)
-		})
-	}
-}

client/sets.go

@@ -9,13 +9,13 @@ import (
 
 // Sets retrieves all sets.
 // This function returns a list of all sets available in the Pokémon TCG database.
-func (s *tcgDexClient) Sets(ctx context.Context) ([]*models.Set, error) {
+func (s *tcgDexClient) Sets(ctx context.Context) ([]models.Set, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/sets", nil)
 	if err != nil {
 		return nil, err
 	}
 
-	sets, err := doRequest[[]*models.Set](s.httpClient, req)
+	sets, err := doRequestSlice[models.Set](s.httpClient, req)
 	if err != nil {
 		return nil, err
 	}
@@ -30,7 +30,7 @@ func (s *tcgDexClient) GetSet(ctx context.Context, setID string) (*models.Set, e
 		return nil, err
 	}
 
-	set, err := doRequest[*models.Set](s.httpClient, req)
+	set, err := doRequest[models.Set](s.httpClient, req)
 	if err != nil {
 		return nil, err
 	}
@@ -46,7 +46,7 @@ func (s *tcgDexClient) GetCardOfSet(ctx context.Context, setID string, cardID st
 		return nil, err
 	}
 
-	card, err := doRequest[*models.Card](s.httpClient, req)
+	card, err := doRequest[models.Card](s.httpClient, req)
 	if err != nil {
 		return nil, err
 	}

client/sets_test.go

@@ -1,27 +1,46 @@
 package client
 
 import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 
+	"github.com/kratisto/tcgdex-golang/models"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGetSetByID(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name    string
 		setID   string
-		wantErr bool
-		wantSet *Set
+		wantErr error
+		wantSet *models.Set
 	}{
-		{"valid set", "xy1", false, &Set{ID: "xy1"}},
-		{"invalid set", "invalid-id", true, nil},
+		{"valid set", "xy1", nil, &models.Set{ID: "xy1"}},
+		{"invalid set", "invalid-id", ErrNotFound, nil},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			set, err := GetSetByID(tt.setID)
+			t.Parallel()
 
-			require.ErrorIs(t, err, ErrNotFound)
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.URL.Path == "/sets/xy1" {
+					w.Header().Set("Content-Type", "application/json")
+					json.NewEncoder(w).Encode(tt.wantSet)
+					return
+				}
+				http.Error(w, "not found", http.StatusNotFound)
+			}))
+			defer server.Close()
+
+			client := NewClientWithCustomHTTPClient(server.URL, "en", server.Client())
+			set, err := client.GetSet(t.Context(), tt.setID)
+
+			require.ErrorIs(t, err, tt.wantErr)
 			require.Equal(t, tt.wantSet, set, "expected set: %v, got: %v for setID %v", tt.wantSet, set, tt.setID)
 		})
 	}

client/stages.go

@@ -0,0 +1,28 @@
+package client
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// Stages retrieves all Pokemon stages.
+func (s *tcgDexClient) Stages(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/stages", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByStage retrieves all cards for a given stage.
+func (s *tcgDexClient) GetCardsByStage(ctx context.Context, stage string) ([]models.Card, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/stages/"+stage, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return doRequestSlice[models.Card](s.httpClient, request)
+}

client/types.go

@@ -0,0 +1,44 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/kratisto/tcgdex-golang/models"
+)
+
+// Types retrieves all types.
+func (s *tcgDexClient) Types(ctx context.Context) ([]string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, s.baseURL+"/types", nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[string](s.httpClient, request)
+}
+
+// GetCardsByType retrieves all cards for a given type.
+func (s *tcgDexClient) GetCardsByType(ctx context.Context, typ string, params *FilterParams) ([]models.Card, error) {
+	endpoint := s.baseURL + "/types/" + typ
+	urlParams := url.Values{}
+	if params != nil {
+		if params.Sort != "" {
+			urlParams.Add("sort", params.Sort)
+		}
+		if params.Page > 0 {
+			urlParams.Add("page", fmt.Sprintf("%d", params.Page))
+		}
+		if params.PageSize > 0 {
+			urlParams.Add("pageSize", fmt.Sprintf("%d", params.PageSize))
+		}
+	}
+	if len(urlParams) > 0 {
+		endpoint += "?" + urlParams.Encode()
+	}
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	return doRequestSlice[models.Card](s.httpClient, request)
+}