roxy.gen.go

// Code generated by roxygen; DO NOT EDIT.
//
// Domain-grouped facade over the generated ClientWithResponses. Each method wraps
// the matching <Operation>WithResponse call and maps a 4xx/5xx response to a
// *RoxyError. Regenerated from the OpenAPI spec on every release.

package roxyapi

import (
	"context"
)

// Roxy is the domain-grouped entry point returned by NewRoxy.
type Roxy struct {
	client         *ClientWithResponses
	Astrology      *AstrologyService
	VedicAstrology *VedicAstrologyService
	Numerology     *NumerologyService
	Tarot          *TarotService
	HumanDesign    *HumanDesignService
	Forecast       *ForecastService
	Biorhythm      *BiorhythmService
	Iching         *IchingService
	Crystals       *CrystalsService
	Dreams         *DreamsService
	AngelNumbers   *AngelNumbersService
	Location       *LocationService
	Usage          *UsageService
	Languages      *LanguagesService
}

func newRoxy(c *ClientWithResponses) *Roxy {
	r := &Roxy{client: c}
	r.Astrology = &AstrologyService{client: c}
	r.VedicAstrology = &VedicAstrologyService{client: c}
	r.Numerology = &NumerologyService{client: c}
	r.Tarot = &TarotService{client: c}
	r.HumanDesign = &HumanDesignService{client: c}
	r.Forecast = &ForecastService{client: c}
	r.Biorhythm = &BiorhythmService{client: c}
	r.Iching = &IchingService{client: c}
	r.Crystals = &CrystalsService{client: c}
	r.Dreams = &DreamsService{client: c}
	r.AngelNumbers = &AngelNumbersService{client: c}
	r.Location = &LocationService{client: c}
	r.Usage = &UsageService{client: c}
	r.Languages = &LanguagesService{client: c}
	return r
}

// AstrologyService groups the astrology endpoints.
type AstrologyService struct{ client *ClientWithResponses }

func (s *AstrologyService) CalculateArabicLots(ctx context.Context, params *CalculateArabicLotsParams, body CalculateArabicLotsJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateArabicLotsResponse, error) {
	resp, err := s.client.CalculateArabicLotsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) CalculateAspects(ctx context.Context, params *CalculateAspectsParams, body CalculateAspectsJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateAspectsResponse, error) {
	resp, err := s.client.CalculateAspectsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) CalculateCompatibility(ctx context.Context, params *CalculateCompatibilityParams, body CalculateCompatibilityJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateCompatibilityResponse, error) {
	resp, err := s.client.CalculateCompatibilityWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) CalculateHouses(ctx context.Context, params *CalculateHousesParams, body CalculateHousesJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateHousesResponse, error) {
	resp, err := s.client.CalculateHousesWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) CalculateSynastry(ctx context.Context, params *CalculateSynastryParams, body CalculateSynastryJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateSynastryResponse, error) {
	resp, err := s.client.CalculateSynastryWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) CalculateTransitAspects(ctx context.Context, params *CalculateTransitAspectsParams, body CalculateTransitAspectsJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateTransitAspectsResponse, error) {
	resp, err := s.client.CalculateTransitAspectsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) CalculateTransits(ctx context.Context, params *CalculateTransitsParams, body CalculateTransitsJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateTransitsResponse, error) {
	resp, err := s.client.CalculateTransitsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) DetectAspectPatterns(ctx context.Context, params *DetectAspectPatternsParams, body DetectAspectPatternsJSONRequestBody, reqEditors ...RequestEditorFn) (*DetectAspectPatternsResponse, error) {
	resp, err := s.client.DetectAspectPatternsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateAsteroids(ctx context.Context, params *GenerateAsteroidsParams, body GenerateAsteroidsJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateAsteroidsResponse, error) {
	resp, err := s.client.GenerateAsteroidsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateAstrocartography(ctx context.Context, params *GenerateAstrocartographyParams, body GenerateAstrocartographyJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateAstrocartographyResponse, error) {
	resp, err := s.client.GenerateAstrocartographyWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateCompositeChart(ctx context.Context, params *GenerateCompositeChartParams, body GenerateCompositeChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateCompositeChartResponse, error) {
	resp, err := s.client.GenerateCompositeChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateFixedStars(ctx context.Context, params *GenerateFixedStarsParams, body GenerateFixedStarsJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateFixedStarsResponse, error) {
	resp, err := s.client.GenerateFixedStarsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateLilith(ctx context.Context, params *GenerateLilithParams, body GenerateLilithJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateLilithResponse, error) {
	resp, err := s.client.GenerateLilithWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateLocalSpace(ctx context.Context, params *GenerateLocalSpaceParams, body GenerateLocalSpaceJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateLocalSpaceResponse, error) {
	resp, err := s.client.GenerateLocalSpaceWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateLunarReturn(ctx context.Context, params *GenerateLunarReturnParams, body GenerateLunarReturnJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateLunarReturnResponse, error) {
	resp, err := s.client.GenerateLunarReturnWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateNatalChart(ctx context.Context, params *GenerateNatalChartParams, body GenerateNatalChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateNatalChartResponse, error) {
	resp, err := s.client.GenerateNatalChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GeneratePlanetaryReturn(ctx context.Context, params *GeneratePlanetaryReturnParams, body GeneratePlanetaryReturnJSONRequestBody, reqEditors ...RequestEditorFn) (*GeneratePlanetaryReturnResponse, error) {
	resp, err := s.client.GeneratePlanetaryReturnWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateProfections(ctx context.Context, params *GenerateProfectionsParams, body GenerateProfectionsJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateProfectionsResponse, error) {
	resp, err := s.client.GenerateProfectionsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateProgressions(ctx context.Context, params *GenerateProgressionsParams, body GenerateProgressionsJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateProgressionsResponse, error) {
	resp, err := s.client.GenerateProgressionsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateRelocationChart(ctx context.Context, params *GenerateRelocationChartParams, body GenerateRelocationChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateRelocationChartResponse, error) {
	resp, err := s.client.GenerateRelocationChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateSolarArc(ctx context.Context, params *GenerateSolarArcParams, body GenerateSolarArcJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateSolarArcResponse, error) {
	resp, err := s.client.GenerateSolarArcWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GenerateSolarReturn(ctx context.Context, params *GenerateSolarReturnParams, body GenerateSolarReturnJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateSolarReturnResponse, error) {
	resp, err := s.client.GenerateSolarReturnWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetCurrentMoonPhase(ctx context.Context, params *GetCurrentMoonPhaseParams, reqEditors ...RequestEditorFn) (*GetCurrentMoonPhaseResponse, error) {
	resp, err := s.client.GetCurrentMoonPhaseWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetDailyHoroscope(ctx context.Context, sign GetDailyHoroscopeParamsSign, params *GetDailyHoroscopeParams, reqEditors ...RequestEditorFn) (*GetDailyHoroscopeResponse, error) {
	resp, err := s.client.GetDailyHoroscopeWithResponse(ctx, sign, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetMonthlyHoroscope(ctx context.Context, sign GetMonthlyHoroscopeParamsSign, params *GetMonthlyHoroscopeParams, reqEditors ...RequestEditorFn) (*GetMonthlyHoroscopeResponse, error) {
	resp, err := s.client.GetMonthlyHoroscopeWithResponse(ctx, sign, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetMoonCalendar(ctx context.Context, year float32, month float32, params *GetMoonCalendarParams, reqEditors ...RequestEditorFn) (*GetMoonCalendarResponse, error) {
	resp, err := s.client.GetMoonCalendarWithResponse(ctx, year, month, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetPlanetMeaning(ctx context.Context, id string, params *GetPlanetMeaningParams, reqEditors ...RequestEditorFn) (*GetPlanetMeaningResponse, error) {
	resp, err := s.client.GetPlanetMeaningWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetPlanetaryPositions(ctx context.Context, params *GetPlanetaryPositionsParams, body GetPlanetaryPositionsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetPlanetaryPositionsResponse, error) {
	resp, err := s.client.GetPlanetaryPositionsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetUpcomingMoonPhases(ctx context.Context, params *GetUpcomingMoonPhasesParams, reqEditors ...RequestEditorFn) (*GetUpcomingMoonPhasesResponse, error) {
	resp, err := s.client.GetUpcomingMoonPhasesWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetWeeklyHoroscope(ctx context.Context, sign GetWeeklyHoroscopeParamsSign, params *GetWeeklyHoroscopeParams, reqEditors ...RequestEditorFn) (*GetWeeklyHoroscopeResponse, error) {
	resp, err := s.client.GetWeeklyHoroscopeWithResponse(ctx, sign, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) GetZodiacSign(ctx context.Context, id string, params *GetZodiacSignParams, reqEditors ...RequestEditorFn) (*GetZodiacSignResponse, error) {
	resp, err := s.client.GetZodiacSignWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) ListPlanetMeanings(ctx context.Context, params *ListPlanetMeaningsParams, reqEditors ...RequestEditorFn) (*ListPlanetMeaningsResponse, error) {
	resp, err := s.client.ListPlanetMeaningsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AstrologyService) ListZodiacSigns(ctx context.Context, params *ListZodiacSignsParams, reqEditors ...RequestEditorFn) (*ListZodiacSignsResponse, error) {
	resp, err := s.client.ListZodiacSignsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// VedicAstrologyService groups the vedic-astrology endpoints.
type VedicAstrologyService struct{ client *ClientWithResponses }

func (s *VedicAstrologyService) CalculateAshtakavarga(ctx context.Context, body CalculateAshtakavargaJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateAshtakavargaResponse, error) {
	resp, err := s.client.CalculateAshtakavargaWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CalculateDrishti(ctx context.Context, body CalculateDrishtiJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateDrishtiResponse, error) {
	resp, err := s.client.CalculateDrishtiWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CalculateGunMilan(ctx context.Context, params *CalculateGunMilanParams, body CalculateGunMilanJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateGunMilanResponse, error) {
	resp, err := s.client.CalculateGunMilanWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CalculateParallels(ctx context.Context, body CalculateParallelsJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateParallelsResponse, error) {
	resp, err := s.client.CalculateParallelsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CalculateShadbala(ctx context.Context, body CalculateShadbalaJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateShadbalaResponse, error) {
	resp, err := s.client.CalculateShadbalaWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CalculateTransit(ctx context.Context, body CalculateTransitJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateTransitResponse, error) {
	resp, err := s.client.CalculateTransitWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CheckKalsarpaDosha(ctx context.Context, body CheckKalsarpaDoshaJSONRequestBody, reqEditors ...RequestEditorFn) (*CheckKalsarpaDoshaResponse, error) {
	resp, err := s.client.CheckKalsarpaDoshaWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CheckManglikDosha(ctx context.Context, body CheckManglikDoshaJSONRequestBody, reqEditors ...RequestEditorFn) (*CheckManglikDoshaResponse, error) {
	resp, err := s.client.CheckManglikDoshaWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) CheckSadhesati(ctx context.Context, body CheckSadhesatiJSONRequestBody, reqEditors ...RequestEditorFn) (*CheckSadhesatiResponse, error) {
	resp, err := s.client.CheckSadhesatiWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) DetectYogas(ctx context.Context, params *DetectYogasParams, body DetectYogasJSONRequestBody, reqEditors ...RequestEditorFn) (*DetectYogasResponse, error) {
	resp, err := s.client.DetectYogasWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GenerateBirthChart(ctx context.Context, params *GenerateBirthChartParams, body GenerateBirthChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateBirthChartResponse, error) {
	resp, err := s.client.GenerateBirthChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GenerateDivisionalChart(ctx context.Context, params *GenerateDivisionalChartParams, body GenerateDivisionalChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateDivisionalChartResponse, error) {
	resp, err := s.client.GenerateDivisionalChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GenerateKpChart(ctx context.Context, params *GenerateKpChartParams, body GenerateKpChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateKpChartResponse, error) {
	resp, err := s.client.GenerateKpChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GenerateNavamsa(ctx context.Context, params *GenerateNavamsaParams, body GenerateNavamsaJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateNavamsaResponse, error) {
	resp, err := s.client.GenerateNavamsaWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetBasicPanchang(ctx context.Context, params *GetBasicPanchangParams, body GetBasicPanchangJSONRequestBody, reqEditors ...RequestEditorFn) (*GetBasicPanchangResponse, error) {
	resp, err := s.client.GetBasicPanchangWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetChoghadiya(ctx context.Context, body GetChoghadiyaJSONRequestBody, reqEditors ...RequestEditorFn) (*GetChoghadiyaResponse, error) {
	resp, err := s.client.GetChoghadiyaWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetCurrentDasha(ctx context.Context, params *GetCurrentDashaParams, body GetCurrentDashaJSONRequestBody, reqEditors ...RequestEditorFn) (*GetCurrentDashaResponse, error) {
	resp, err := s.client.GetCurrentDashaWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetDetailedPanchang(ctx context.Context, params *GetDetailedPanchangParams, body GetDetailedPanchangJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDetailedPanchangResponse, error) {
	resp, err := s.client.GetDetailedPanchangWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetEclipticCrossings(ctx context.Context, body GetEclipticCrossingsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetEclipticCrossingsResponse, error) {
	resp, err := s.client.GetEclipticCrossingsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetHora(ctx context.Context, body GetHoraJSONRequestBody, reqEditors ...RequestEditorFn) (*GetHoraResponse, error) {
	resp, err := s.client.GetHoraWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpAyanamsa(ctx context.Context, params *GetKpAyanamsaParams, reqEditors ...RequestEditorFn) (*GetKpAyanamsaResponse, error) {
	resp, err := s.client.GetKpAyanamsaWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpCusps(ctx context.Context, body GetKpCuspsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpCuspsResponse, error) {
	resp, err := s.client.GetKpCuspsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpPlanetsInterval(ctx context.Context, body GetKpPlanetsIntervalJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpPlanetsIntervalResponse, error) {
	resp, err := s.client.GetKpPlanetsIntervalWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpPlanets(ctx context.Context, body GetKpPlanetsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpPlanetsResponse, error) {
	resp, err := s.client.GetKpPlanetsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpRasiChanges(ctx context.Context, body GetKpRasiChangesJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpRasiChangesResponse, error) {
	resp, err := s.client.GetKpRasiChangesWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpRulingInterval(ctx context.Context, body GetKpRulingIntervalJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpRulingIntervalResponse, error) {
	resp, err := s.client.GetKpRulingIntervalWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpRulingPlanets(ctx context.Context, body GetKpRulingPlanetsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpRulingPlanetsResponse, error) {
	resp, err := s.client.GetKpRulingPlanetsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetKpSublordChanges(ctx context.Context, body GetKpSublordChangesJSONRequestBody, reqEditors ...RequestEditorFn) (*GetKpSublordChangesResponse, error) {
	resp, err := s.client.GetKpSublordChangesWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetLunarAspects(ctx context.Context, body GetLunarAspectsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetLunarAspectsResponse, error) {
	resp, err := s.client.GetLunarAspectsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetMajorDashas(ctx context.Context, params *GetMajorDashasParams, body GetMajorDashasJSONRequestBody, reqEditors ...RequestEditorFn) (*GetMajorDashasResponse, error) {
	resp, err := s.client.GetMajorDashasWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetMonthlyAspects(ctx context.Context, body GetMonthlyAspectsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetMonthlyAspectsResponse, error) {
	resp, err := s.client.GetMonthlyAspectsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetMonthlyEphemeris(ctx context.Context, body GetMonthlyEphemerisJSONRequestBody, reqEditors ...RequestEditorFn) (*GetMonthlyEphemerisResponse, error) {
	resp, err := s.client.GetMonthlyEphemerisWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetMonthlyParallels(ctx context.Context, body GetMonthlyParallelsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetMonthlyParallelsResponse, error) {
	resp, err := s.client.GetMonthlyParallelsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetMonthlyTransits(ctx context.Context, body GetMonthlyTransitsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetMonthlyTransitsResponse, error) {
	resp, err := s.client.GetMonthlyTransitsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetNakshatra(ctx context.Context, id GetNakshatraParamsID, params *GetNakshatraParams, reqEditors ...RequestEditorFn) (*GetNakshatraResponse, error) {
	resp, err := s.client.GetNakshatraWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetPlanetPositions(ctx context.Context, params *GetPlanetPositionsParams, body GetPlanetPositionsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetPlanetPositionsResponse, error) {
	resp, err := s.client.GetPlanetPositionsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetRashi(ctx context.Context, id GetRashiParamsID, params *GetRashiParams, reqEditors ...RequestEditorFn) (*GetRashiResponse, error) {
	resp, err := s.client.GetRashiWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetSubDashas(ctx context.Context, mahadasha GetSubDashasParamsMahadasha, params *GetSubDashasParams, body GetSubDashasJSONRequestBody, reqEditors ...RequestEditorFn) (*GetSubDashasResponse, error) {
	resp, err := s.client.GetSubDashasWithResponse(ctx, mahadasha, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetUpagrahaPositions(ctx context.Context, body GetUpagrahaPositionsJSONRequestBody, reqEditors ...RequestEditorFn) (*GetUpagrahaPositionsResponse, error) {
	resp, err := s.client.GetUpagrahaPositionsWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) GetYoga(ctx context.Context, id GetYogaParamsID, params *GetYogaParams, reqEditors ...RequestEditorFn) (*GetYogaResponse, error) {
	resp, err := s.client.GetYogaWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) ListNakshatras(ctx context.Context, params *ListNakshatrasParams, reqEditors ...RequestEditorFn) (*ListNakshatrasResponse, error) {
	resp, err := s.client.ListNakshatrasWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) ListRashis(ctx context.Context, params *ListRashisParams, reqEditors ...RequestEditorFn) (*ListRashisResponse, error) {
	resp, err := s.client.ListRashisWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *VedicAstrologyService) ListYogas(ctx context.Context, params *ListYogasParams, reqEditors ...RequestEditorFn) (*ListYogasResponse, error) {
	resp, err := s.client.ListYogasWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// NumerologyService groups the numerology endpoints.
type NumerologyService struct{ client *ClientWithResponses }

func (s *NumerologyService) AnalyzeKarmicLessons(ctx context.Context, params *AnalyzeKarmicLessonsParams, body AnalyzeKarmicLessonsJSONRequestBody, reqEditors ...RequestEditorFn) (*AnalyzeKarmicLessonsResponse, error) {
	resp, err := s.client.AnalyzeKarmicLessonsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateBirthDay(ctx context.Context, params *CalculateBirthDayParams, body CalculateBirthDayJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateBirthDayResponse, error) {
	resp, err := s.client.CalculateBirthDayWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateBridgeNumbers(ctx context.Context, params *CalculateBridgeNumbersParams, body CalculateBridgeNumbersJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateBridgeNumbersResponse, error) {
	resp, err := s.client.CalculateBridgeNumbersWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateBusinessName(ctx context.Context, params *CalculateBusinessNameParams, body CalculateBusinessNameJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateBusinessNameResponse, error) {
	resp, err := s.client.CalculateBusinessNameWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateChaldean(ctx context.Context, params *CalculateChaldeanParams, body CalculateChaldeanJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateChaldeanResponse, error) {
	resp, err := s.client.CalculateChaldeanWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateDual(ctx context.Context, params *CalculateDualParams, body CalculateDualJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateDualResponse, error) {
	resp, err := s.client.CalculateDualWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateExpression(ctx context.Context, params *CalculateExpressionParams, body CalculateExpressionJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateExpressionResponse, error) {
	resp, err := s.client.CalculateExpressionWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateLifePath(ctx context.Context, params *CalculateLifePathParams, body CalculateLifePathJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateLifePathResponse, error) {
	resp, err := s.client.CalculateLifePathWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateMaturity(ctx context.Context, params *CalculateMaturityParams, body CalculateMaturityJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateMaturityResponse, error) {
	resp, err := s.client.CalculateMaturityWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateNumCompatibility(ctx context.Context, params *CalculateNumCompatibilityParams, body CalculateNumCompatibilityJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateNumCompatibilityResponse, error) {
	resp, err := s.client.CalculateNumCompatibilityWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculatePersonalDay(ctx context.Context, params *CalculatePersonalDayParams, body CalculatePersonalDayJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculatePersonalDayResponse, error) {
	resp, err := s.client.CalculatePersonalDayWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculatePersonalMonth(ctx context.Context, params *CalculatePersonalMonthParams, body CalculatePersonalMonthJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculatePersonalMonthResponse, error) {
	resp, err := s.client.CalculatePersonalMonthWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculatePersonalYear(ctx context.Context, params *CalculatePersonalYearParams, body CalculatePersonalYearJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculatePersonalYearResponse, error) {
	resp, err := s.client.CalculatePersonalYearWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculatePersonality(ctx context.Context, params *CalculatePersonalityParams, body CalculatePersonalityJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculatePersonalityResponse, error) {
	resp, err := s.client.CalculatePersonalityWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CalculateSoulUrge(ctx context.Context, params *CalculateSoulUrgeParams, body CalculateSoulUrgeJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateSoulUrgeResponse, error) {
	resp, err := s.client.CalculateSoulUrgeWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) CheckKarmicDebt(ctx context.Context, params *CheckKarmicDebtParams, body CheckKarmicDebtJSONRequestBody, reqEditors ...RequestEditorFn) (*CheckKarmicDebtResponse, error) {
	resp, err := s.client.CheckKarmicDebtWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) GenerateNumerologyChart(ctx context.Context, params *GenerateNumerologyChartParams, body GenerateNumerologyChartJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateNumerologyChartResponse, error) {
	resp, err := s.client.GenerateNumerologyChartWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) GetCompoundNumber(ctx context.Context, number string, params *GetCompoundNumberParams, reqEditors ...RequestEditorFn) (*GetCompoundNumberResponse, error) {
	resp, err := s.client.GetCompoundNumberWithResponse(ctx, number, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) GetDailyNumber(ctx context.Context, params *GetDailyNumberParams, body GetDailyNumberJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyNumberResponse, error) {
	resp, err := s.client.GetDailyNumberWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *NumerologyService) GetNumberMeaning(ctx context.Context, number string, params *GetNumberMeaningParams, reqEditors ...RequestEditorFn) (*GetNumberMeaningResponse, error) {
	resp, err := s.client.GetNumberMeaningWithResponse(ctx, number, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// TarotService groups the tarot endpoints.
type TarotService struct{ client *ClientWithResponses }

func (s *TarotService) CastCareerSpread(ctx context.Context, params *CastCareerSpreadParams, body CastCareerSpreadJSONRequestBody, reqEditors ...RequestEditorFn) (*CastCareerSpreadResponse, error) {
	resp, err := s.client.CastCareerSpreadWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) CastCelticCross(ctx context.Context, params *CastCelticCrossParams, body CastCelticCrossJSONRequestBody, reqEditors ...RequestEditorFn) (*CastCelticCrossResponse, error) {
	resp, err := s.client.CastCelticCrossWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) CastCustomSpread(ctx context.Context, params *CastCustomSpreadParams, body CastCustomSpreadJSONRequestBody, reqEditors ...RequestEditorFn) (*CastCustomSpreadResponse, error) {
	resp, err := s.client.CastCustomSpreadWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) CastLoveSpread(ctx context.Context, params *CastLoveSpreadParams, body CastLoveSpreadJSONRequestBody, reqEditors ...RequestEditorFn) (*CastLoveSpreadResponse, error) {
	resp, err := s.client.CastLoveSpreadWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) CastThreeCard(ctx context.Context, params *CastThreeCardParams, body CastThreeCardJSONRequestBody, reqEditors ...RequestEditorFn) (*CastThreeCardResponse, error) {
	resp, err := s.client.CastThreeCardWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) CastYesNo(ctx context.Context, params *CastYesNoParams, body CastYesNoJSONRequestBody, reqEditors ...RequestEditorFn) (*CastYesNoResponse, error) {
	resp, err := s.client.CastYesNoWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) DrawCards(ctx context.Context, params *DrawCardsParams, body DrawCardsJSONRequestBody, reqEditors ...RequestEditorFn) (*DrawCardsResponse, error) {
	resp, err := s.client.DrawCardsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) GetCard(ctx context.Context, id string, params *GetCardParams, reqEditors ...RequestEditorFn) (*GetCardResponse, error) {
	resp, err := s.client.GetCardWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) GetDailyCard(ctx context.Context, params *GetDailyCardParams, body GetDailyCardJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyCardResponse, error) {
	resp, err := s.client.GetDailyCardWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *TarotService) ListCards(ctx context.Context, params *ListCardsParams, reqEditors ...RequestEditorFn) (*ListCardsResponse, error) {
	resp, err := s.client.ListCardsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// HumanDesignService groups the human-design endpoints.
type HumanDesignService struct{ client *ClientWithResponses }

func (s *HumanDesignService) CalculateCenters(ctx context.Context, params *CalculateCentersParams, body CalculateCentersJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateCentersResponse, error) {
	resp, err := s.client.CalculateCentersWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculateChannels(ctx context.Context, params *CalculateChannelsParams, body CalculateChannelsJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateChannelsResponse, error) {
	resp, err := s.client.CalculateChannelsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculateConnection(ctx context.Context, params *CalculateConnectionParams, body CalculateConnectionJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateConnectionResponse, error) {
	resp, err := s.client.CalculateConnectionWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculateGates(ctx context.Context, params *CalculateGatesParams, body CalculateGatesJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateGatesResponse, error) {
	resp, err := s.client.CalculateGatesWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculatePenta(ctx context.Context, params *CalculatePentaParams, body CalculatePentaJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculatePentaResponse, error) {
	resp, err := s.client.CalculatePentaWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculateProfile(ctx context.Context, params *CalculateProfileParams, body CalculateProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateProfileResponse, error) {
	resp, err := s.client.CalculateProfileWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculateType(ctx context.Context, params *CalculateTypeParams, body CalculateTypeJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateTypeResponse, error) {
	resp, err := s.client.CalculateTypeWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) CalculateVariables(ctx context.Context, params *CalculateVariablesParams, body CalculateVariablesJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateVariablesResponse, error) {
	resp, err := s.client.CalculateVariablesWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) GenerateBodygraph(ctx context.Context, params *GenerateBodygraphParams, body GenerateBodygraphJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateBodygraphResponse, error) {
	resp, err := s.client.GenerateBodygraphWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) GenerateTransit(ctx context.Context, params *GenerateTransitParams, body GenerateTransitJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateTransitResponse, error) {
	resp, err := s.client.GenerateTransitWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) GetCenter(ctx context.Context, id GetCenterParamsID, params *GetCenterParams, reqEditors ...RequestEditorFn) (*GetCenterResponse, error) {
	resp, err := s.client.GetCenterWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *HumanDesignService) GetGate(ctx context.Context, number int, params *GetGateParams, reqEditors ...RequestEditorFn) (*GetGateResponse, error) {
	resp, err := s.client.GetGateWithResponse(ctx, number, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// ForecastService groups the forecast endpoints.
type ForecastService struct{ client *ClientWithResponses }

func (s *ForecastService) FindSignificantDates(ctx context.Context, params *FindSignificantDatesParams, body FindSignificantDatesJSONRequestBody, reqEditors ...RequestEditorFn) (*FindSignificantDatesResponse, error) {
	resp, err := s.client.FindSignificantDatesWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *ForecastService) ForecastSolarReturn(ctx context.Context, params *ForecastSolarReturnParams, body ForecastSolarReturnJSONRequestBody, reqEditors ...RequestEditorFn) (*ForecastSolarReturnResponse, error) {
	resp, err := s.client.ForecastSolarReturnWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *ForecastService) ForecastTransits(ctx context.Context, params *ForecastTransitsParams, body ForecastTransitsJSONRequestBody, reqEditors ...RequestEditorFn) (*ForecastTransitsResponse, error) {
	resp, err := s.client.ForecastTransitsWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *ForecastService) GenerateDigest(ctx context.Context, params *GenerateDigestParams, body GenerateDigestJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateDigestResponse, error) {
	resp, err := s.client.GenerateDigestWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *ForecastService) GenerateTimeline(ctx context.Context, params *GenerateTimelineParams, body GenerateTimelineJSONRequestBody, reqEditors ...RequestEditorFn) (*GenerateTimelineResponse, error) {
	resp, err := s.client.GenerateTimelineWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// BiorhythmService groups the biorhythm endpoints.
type BiorhythmService struct{ client *ClientWithResponses }

func (s *BiorhythmService) CalculateBioCompatibility(ctx context.Context, params *CalculateBioCompatibilityParams, body CalculateBioCompatibilityJSONRequestBody, reqEditors ...RequestEditorFn) (*CalculateBioCompatibilityResponse, error) {
	resp, err := s.client.CalculateBioCompatibilityWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *BiorhythmService) GetCriticalDays(ctx context.Context, params *GetCriticalDaysParams, body GetCriticalDaysJSONRequestBody, reqEditors ...RequestEditorFn) (*GetCriticalDaysResponse, error) {
	resp, err := s.client.GetCriticalDaysWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *BiorhythmService) GetDailyBiorhythm(ctx context.Context, params *GetDailyBiorhythmParams, body GetDailyBiorhythmJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyBiorhythmResponse, error) {
	resp, err := s.client.GetDailyBiorhythmWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *BiorhythmService) GetForecast(ctx context.Context, params *GetForecastParams, body GetForecastJSONRequestBody, reqEditors ...RequestEditorFn) (*GetForecastResponse, error) {
	resp, err := s.client.GetForecastWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *BiorhythmService) GetPhases(ctx context.Context, params *GetPhasesParams, body GetPhasesJSONRequestBody, reqEditors ...RequestEditorFn) (*GetPhasesResponse, error) {
	resp, err := s.client.GetPhasesWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *BiorhythmService) GetReading(ctx context.Context, params *GetReadingParams, body GetReadingJSONRequestBody, reqEditors ...RequestEditorFn) (*GetReadingResponse, error) {
	resp, err := s.client.GetReadingWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// IchingService groups the iching endpoints.
type IchingService struct{ client *ClientWithResponses }

func (s *IchingService) CastDailyReading(ctx context.Context, params *CastDailyReadingParams, body CastDailyReadingJSONRequestBody, reqEditors ...RequestEditorFn) (*CastDailyReadingResponse, error) {
	resp, err := s.client.CastDailyReadingWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) CastReading(ctx context.Context, params *CastReadingParams, reqEditors ...RequestEditorFn) (*CastReadingResponse, error) {
	resp, err := s.client.CastReadingWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) GetDailyHexagram(ctx context.Context, params *GetDailyHexagramParams, body GetDailyHexagramJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyHexagramResponse, error) {
	resp, err := s.client.GetDailyHexagramWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) GetHexagram(ctx context.Context, number float32, params *GetHexagramParams, reqEditors ...RequestEditorFn) (*GetHexagramResponse, error) {
	resp, err := s.client.GetHexagramWithResponse(ctx, number, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) GetRandomHexagram(ctx context.Context, params *GetRandomHexagramParams, reqEditors ...RequestEditorFn) (*GetRandomHexagramResponse, error) {
	resp, err := s.client.GetRandomHexagramWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) GetTrigram(ctx context.Context, id string, params *GetTrigramParams, reqEditors ...RequestEditorFn) (*GetTrigramResponse, error) {
	resp, err := s.client.GetTrigramWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) ListHexagrams(ctx context.Context, params *ListHexagramsParams, reqEditors ...RequestEditorFn) (*ListHexagramsResponse, error) {
	resp, err := s.client.ListHexagramsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) ListTrigrams(ctx context.Context, params *ListTrigramsParams, reqEditors ...RequestEditorFn) (*ListTrigramsResponse, error) {
	resp, err := s.client.ListTrigramsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *IchingService) LookupHexagram(ctx context.Context, params *LookupHexagramParams, reqEditors ...RequestEditorFn) (*LookupHexagramResponse, error) {
	resp, err := s.client.LookupHexagramWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// CrystalsService groups the crystals endpoints.
type CrystalsService struct{ client *ClientWithResponses }

func (s *CrystalsService) GetBirthstones(ctx context.Context, month int, params *GetBirthstonesParams, reqEditors ...RequestEditorFn) (*GetBirthstonesResponse, error) {
	resp, err := s.client.GetBirthstonesWithResponse(ctx, month, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetCrystalPairings(ctx context.Context, id string, params *GetCrystalPairingsParams, reqEditors ...RequestEditorFn) (*GetCrystalPairingsResponse, error) {
	resp, err := s.client.GetCrystalPairingsWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetCrystal(ctx context.Context, id string, params *GetCrystalParams, reqEditors ...RequestEditorFn) (*GetCrystalResponse, error) {
	resp, err := s.client.GetCrystalWithResponse(ctx, id, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetCrystalsByChakra(ctx context.Context, chakra GetCrystalsByChakraParamsChakra, params *GetCrystalsByChakraParams, reqEditors ...RequestEditorFn) (*GetCrystalsByChakraResponse, error) {
	resp, err := s.client.GetCrystalsByChakraWithResponse(ctx, chakra, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetCrystalsByElement(ctx context.Context, element GetCrystalsByElementParamsElement, params *GetCrystalsByElementParams, reqEditors ...RequestEditorFn) (*GetCrystalsByElementResponse, error) {
	resp, err := s.client.GetCrystalsByElementWithResponse(ctx, element, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetCrystalsByZodiac(ctx context.Context, sign GetCrystalsByZodiacParamsSign, params *GetCrystalsByZodiacParams, reqEditors ...RequestEditorFn) (*GetCrystalsByZodiacResponse, error) {
	resp, err := s.client.GetCrystalsByZodiacWithResponse(ctx, sign, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetDailyCrystal(ctx context.Context, params *GetDailyCrystalParams, body GetDailyCrystalJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyCrystalResponse, error) {
	resp, err := s.client.GetDailyCrystalWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) GetRandomCrystal(ctx context.Context, params *GetRandomCrystalParams, reqEditors ...RequestEditorFn) (*GetRandomCrystalResponse, error) {
	resp, err := s.client.GetRandomCrystalWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) ListCrystalColors(ctx context.Context, reqEditors ...RequestEditorFn) (*ListCrystalColorsResponse, error) {
	resp, err := s.client.ListCrystalColorsWithResponse(ctx, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) ListCrystalPlanets(ctx context.Context, reqEditors ...RequestEditorFn) (*ListCrystalPlanetsResponse, error) {
	resp, err := s.client.ListCrystalPlanetsWithResponse(ctx, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) ListCrystals(ctx context.Context, params *ListCrystalsParams, reqEditors ...RequestEditorFn) (*ListCrystalsResponse, error) {
	resp, err := s.client.ListCrystalsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *CrystalsService) SearchCrystals(ctx context.Context, params *SearchCrystalsParams, reqEditors ...RequestEditorFn) (*SearchCrystalsResponse, error) {
	resp, err := s.client.SearchCrystalsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// DreamsService groups the dreams endpoints.
type DreamsService struct{ client *ClientWithResponses }

func (s *DreamsService) GetDailyDreamSymbol(ctx context.Context, body GetDailyDreamSymbolJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyDreamSymbolResponse, error) {
	resp, err := s.client.GetDailyDreamSymbolWithResponse(ctx, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *DreamsService) GetDreamSymbol(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*GetDreamSymbolResponse, error) {
	resp, err := s.client.GetDreamSymbolWithResponse(ctx, id, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *DreamsService) GetRandomSymbols(ctx context.Context, params *GetRandomSymbolsParams, reqEditors ...RequestEditorFn) (*GetRandomSymbolsResponse, error) {
	resp, err := s.client.GetRandomSymbolsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *DreamsService) GetSymbolLetterCounts(ctx context.Context, reqEditors ...RequestEditorFn) (*GetSymbolLetterCountsResponse, error) {
	resp, err := s.client.GetSymbolLetterCountsWithResponse(ctx, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *DreamsService) SearchDreamSymbols(ctx context.Context, params *SearchDreamSymbolsParams, reqEditors ...RequestEditorFn) (*SearchDreamSymbolsResponse, error) {
	resp, err := s.client.SearchDreamSymbolsWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// AngelNumbersService groups the angel-numbers endpoints.
type AngelNumbersService struct{ client *ClientWithResponses }

func (s *AngelNumbersService) AnalyzeNumberSequence(ctx context.Context, params *AnalyzeNumberSequenceParams, reqEditors ...RequestEditorFn) (*AnalyzeNumberSequenceResponse, error) {
	resp, err := s.client.AnalyzeNumberSequenceWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AngelNumbersService) GetAngelNumber(ctx context.Context, number string, params *GetAngelNumberParams, reqEditors ...RequestEditorFn) (*GetAngelNumberResponse, error) {
	resp, err := s.client.GetAngelNumberWithResponse(ctx, number, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AngelNumbersService) GetDailyAngelNumber(ctx context.Context, params *GetDailyAngelNumberParams, body GetDailyAngelNumberJSONRequestBody, reqEditors ...RequestEditorFn) (*GetDailyAngelNumberResponse, error) {
	resp, err := s.client.GetDailyAngelNumberWithResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *AngelNumbersService) ListAngelNumbers(ctx context.Context, params *ListAngelNumbersParams, reqEditors ...RequestEditorFn) (*ListAngelNumbersResponse, error) {
	resp, err := s.client.ListAngelNumbersWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// LocationService groups the location endpoints.
type LocationService struct{ client *ClientWithResponses }

func (s *LocationService) GetCitiesByCountry(ctx context.Context, iso2 string, params *GetCitiesByCountryParams, reqEditors ...RequestEditorFn) (*GetCitiesByCountryResponse, error) {
	resp, err := s.client.GetCitiesByCountryWithResponse(ctx, iso2, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *LocationService) ListCountries(ctx context.Context, params *ListCountriesParams, reqEditors ...RequestEditorFn) (*ListCountriesResponse, error) {
	resp, err := s.client.ListCountriesWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

func (s *LocationService) SearchCities(ctx context.Context, params *SearchCitiesParams, reqEditors ...RequestEditorFn) (*SearchCitiesResponse, error) {
	resp, err := s.client.SearchCitiesWithResponse(ctx, params, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// UsageService groups the usage endpoints.
type UsageService struct{ client *ClientWithResponses }

func (s *UsageService) GetUsageStats(ctx context.Context, reqEditors ...RequestEditorFn) (*GetUsageStatsResponse, error) {
	resp, err := s.client.GetUsageStatsWithResponse(ctx, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}

// LanguagesService groups the languages endpoints.
type LanguagesService struct{ client *ClientWithResponses }

func (s *LanguagesService) ListLanguages(ctx context.Context, reqEditors ...RequestEditorFn) (*ListLanguagesResponse, error) {
	resp, err := s.client.ListLanguagesWithResponse(ctx, reqEditors...)
	if err != nil {
		return resp, err
	}
	return resp, asRoxyError(resp)
}