@vertikalx/vtx-backend-client 3.0.0-dev.8 → 3.0.1-dev-max.0

package/src/api/vtx-base-api.ts

@@ -0,0 +1,2253 @@
+import pjson from '../../package.json';
+import { GraphQLClient } from 'graphql-request';
+import { getSdk, Sdk } from '../generated/graphql';
+import {
+  CreateActiveUserInput, User, AddValuesResponse, UserToken, UserWithToken, Athlete, RegisterAthleteDto, Brand, CreateBrandDto,
+  AWSS3UploadUrl, AWSS3GetUploadDto, RefreshTokenInput, CreateTenantInput, Tenant,
+  TenantWithUserLogin, RegisterUserToDomainFromEmailInput,
+  DecodedToken, Sponsorship, DomainCredential, CreateSponsorshipDto, SponsorAthleteInvitation, InviteAthletesDto,
+  RegisterUserDto, VerificationCode, FindSponsorAthleteInvitationDto, FindVtxUserDto, City,
+  SportLevel, Sport, EditValueResponse, EditValueDto, CreateAthleteCompetitionDto, AthleteCompetition,
+  GetSportEventsDto, SportsEvent, CreateSportEventDto, UpdateSportEventDto, GetAthleteCompetitionsDto,
+  AthleteMembership, MembershipOrganizationReference, CreateMembershipOrganizationDto, CreateAthleteMembershipDto,
+  DeleteSingleValueDto, DeleteSingleValueResponse, FundRaisingCampaign, CreateFundingCampaignDto,
+  AthleteQueryDto, AthleteQueryResponse, CreateStripeAccountDto, StripeAccount, StripeSession,
+  StripeAccountReference, StripeCheckoutSession, DonationCheckoutDto, GetDatabaseFileDto, TextDatabaseFile,
+  StripeQueryDto, StripeObject, SetFundingStatusDto, EditPictureResponse, UploadAlbumsPicturesDto,
+  AWSS3DeleteUseTypeFileDto, UpdateUserSuspendedStatusDto, EditPictureDto, Album, State, Country,
+  AWSS3DeleteUseTypeKeyDto, AthleteIntegrationReference, AWSS3CallResult, SetCompetitionResultDto,
+  AthleteCompetitionResult, CreateVerificationCodeDto, CodeVerificationResponse, resetPasswordDto,
+  DeleteValuesDto, DeleteValuesResponse, ExistValueResponse, Receipt, ReceiptUrl, GetReceiptDto,
+  BudgetData, AddCompetitionBudgetDto, EditCompetitionBudgetDto, EditCampaignBudgetDto,
+  SetCurrentCampaignDto, GetAthleteCampaignsDto, BrowseCampaignsDto, BrowseCampaignsResult,
+  UpdateFundingCampaignDto, EditDisplayIndexDto, MergeEventsResponse, MergeSportsEventsDto,
+  BudgetConcept, BudgetItemUnit, CompetitionDeleteVerificationResponse,
+  RegisterMemberDto, Member, Donation, GetHistoricalScoresDto, HistoricalScore,
+  GetMyHistoricalScoresDto, HistoricalScoresPeriod, GetTransactionDetailsDto, TransactionDetails,
+  AdminUserView, AdminTransactionView, PaginatedTransactions, TransactionQueryDto,
+  PaginatedUsers, UserQueryDto, EventQueryDto, PaginatedSports, SportQueryDto,
+  StripeBalance, DeleteVtxUserDto, DeleteVtxUserResponse, ForceScoreRefreshResponse,
+  Offer, CreateOfferDto, Sponsor, CreateSponsorDto, PaginatedBrands, BrandQueryDto,
+  PaginatedEvents, SponsorQueryDto, PaginatedSponsors, OfferQueryDto, PaginatedOffers,
+  PaginatedOffersWithEligibility, UploadResult, OfferClaim, OfferClaimQueryDto,
+  LeaderboardResponse, UserRank, LeaderboardQueryDto, UserRankQueryDto,
+  DashboardSummary, ScoreHistoryEntry, RankHistoryEntry, RankContext,
+  ActivitiesResponse, ActivityDetail, ComponentSummary,
+  ScoreHistoryQueryDto, RankHistoryQueryDto, RankContextQueryDto,
+  ActivitiesQueryDto, ActivityDetailQueryDto, ComponentSummaryQueryDto,
+  ActivityDatesResponse, ActivityDatesQueryDto, Platform, PeriodType, ContentType, PostSortOption,
+  Notification, NotificationListResponse, UnreadCountResponse, NotificationPreference,
+  NotificationQueryDto, MarkNotificationReadDto, DismissNotificationDto, UpdateNotificationPreferenceDto,
+  DeviceTokenType, RegisterDeviceTokenDto, UnregisterDeviceTokenDto,
+  FollowedAthletesListResponse, IsFollowingResponse, FollowAthleteInput, UnfollowAthleteInput,
+  IsFollowingAthleteInput, FollowedAthletesQueryInput,
+  DonationDates, PaginatedDonations, DonationQueryDto,
+  existValueDto, VerifyCodeDto,
+} from '../client';
+
+import { ITypedBackendResponse } from './backend-response';
+import { APICallHeaders, DEFAULT_HEADERS } from './api-call-headers';
+import { buildErrorResponse, buildResponse } from './response-builder';
+import { DOMAIN_SPONSOR } from './domains';
+import { VTX_ERRORS } from '@vertikalx/vtx-core-common';
+import { CodeVerificationResponseType, VerificationCodeType } from '@vertikalx/common-types';
+import { Campaign } from '@vertikalx/vtx-core-models';
+
+
+export class VTXBaseAPI {
+  protected headers: APICallHeaders;
+  protected backendUrl: string;
+  protected gqlClient: GraphQLClient;
+  protected sdk: Sdk;
+
+  protected static Logger = {
+    debug: (str: any) => {
+      //console.debug(str);
+    },
+    log: (str: any) => {
+      console.log(str);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    warn: (str: any) => {
+      //console.warn(str);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    error: (str: any) => {
+      //console.error(str);
+    },
+  }
+
+  constructor(backendUrl: string, headers?: APICallHeaders, requestConfig?: { fetch?: typeof fetch }) {
+    this.headers = headers ?? DEFAULT_HEADERS;
+    this.backendUrl = backendUrl;
+    this.gqlClient = new GraphQLClient(backendUrl + '/graphql', {
+      headers: this.headers as Record<string, string>,
+      ...(requestConfig?.fetch ? { fetch: requestConfig.fetch } : {}),
+    });
+    this.sdk = getSdk(this.gqlClient);
+  }
+
+  public getHeaders(): APICallHeaders {
+    return this.headers;
+  }
+
+  public setHeader(key: string, value: string) {
+    this.headers[key] = value;
+    this.gqlClient.setHeaders(this.headers as Record<string, string>);
+  }
+
+  public static getVersion(): string {
+    return pjson?.version ?? '0.0.0';
+  }
+
+  public static isBrowser(): boolean {
+    if (typeof process === 'object' && typeof require === 'function') {
+      return false;
+    }
+    if (typeof importScripts === 'function') {
+      return false;
+    }
+    if (typeof window === 'object') {
+      return true;
+    }
+    return false;
+  }
+
+  // Generic execute wrapper for SDK calls
+  protected async execute<T>(
+    sdkCall: () => Promise<any>,
+    rootProperty: string,
+    checker: (response: any) => boolean,
+    logPrefix: string
+  ): Promise<ITypedBackendResponse<T>> {
+    let retValue: ITypedBackendResponse<T> = {};
+    try {
+      const response = await sdkCall();
+      VTXBaseAPI.Logger.debug(`${logPrefix} Response:`);
+      VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+      retValue = buildResponse<T>(response, rootProperty, checker);
+    } catch (err1: any) {
+      VTXBaseAPI.Logger.error(`${logPrefix} err1:`);
+      VTXBaseAPI.Logger.error(err1);
+      retValue = buildErrorResponse<T>(err1);
+    }
+    return retValue;
+  }
+
+  // ============= AUTH / USER METHODS =============
+
+  public async findUserByEmail(email: string): Promise<ITypedBackendResponse<User>> {
+    const curatedEmail = email.trim().toLocaleLowerCase();
+    return this.execute<User>(
+      () => this.sdk.FindUserByEmail({ email: curatedEmail }),
+      'findUserByEmail',
+      (r) => !!r?.findUserByEmail?._id,
+      'findUserByEmail'
+    );
+  }
+
+  public async loginUserFromEmail(loginEmail: string, loginMethod: string = ""): Promise<ITypedBackendResponse<UserToken>> {
+    const curatedEmail = loginEmail.trim().toLocaleLowerCase();
+    return this.execute<UserToken>(
+      () => this.sdk.LoginUserFromEmail({ email: curatedEmail, loginMethod }),
+      'loginUserFromEmail',
+      (r) => !!r?.loginUserFromEmail?.actualToken,
+      'loginUserFromEmail'
+    );
+  }
+
+  public async createUserAndLogin(loginEmail: string): Promise<ITypedBackendResponse<UserWithToken>> {
+    const curatedEmail = loginEmail.trim().toLowerCase();
+    const payload: CreateActiveUserInput = { loginEmail: curatedEmail };
+    return this.execute<UserWithToken>(
+      () => this.sdk.CreateUserAndLogin({ user: payload }),
+      'createUserAndLogin',
+      (r) => !!r?.createUserAndLogin?._id,
+      'createUserAndLogin'
+    );
+  }
+
+  public async registerMember(dto: RegisterMemberDto): Promise<ITypedBackendResponse<Member>> {
+    return this.execute<Member>(
+      () => this.sdk.RegisterMember({ input: dto }),
+      'registerMember',
+      (r) => !!r?.registerMember?._id,
+      'registerMember'
+    );
+  }
+
+  public async registerAthlete(payload: RegisterAthleteDto): Promise<ITypedBackendResponse<Athlete>> {
+    return this.execute<Athlete>(
+      () => this.sdk.RegisterAthlete({ input: payload }),
+      'registerAthlete',
+      (r) => !!r?.registerAthlete?._id,
+      'registerAthlete'
+    );
+  }
+
+  public async findBrandByName(name: string, translations: boolean = false): Promise<ITypedBackendResponse<Brand>> {
+    return this.execute<Brand>(
+      () => this.sdk.FindBrandByName({ name, translations }),
+      'getBrandByName',
+      (r) => !!r?.getBrandByName?._id,
+      'getBrandByName'
+    );
+  }
+
+  public async createBrand(dto: CreateBrandDto): Promise<ITypedBackendResponse<Brand>> {
+    return this.execute<Brand>(
+      () => this.sdk.CreateBrand({ input: dto }),
+      'createBrand',
+      (r) => !!r?.createBrand?._id,
+      'createBrand'
+    );
+  }
+
+  public async createSponsorship(dto: CreateSponsorshipDto, _desiredFields?: any): Promise<ITypedBackendResponse<Sponsorship>> {
+    return this.execute<Sponsorship>(
+      () => this.sdk.CreateSponsorship({ input: dto }),
+      'createSponsorship',
+      (r) => !!r?.createSponsorship?._id,
+      'createSponsorship'
+    );
+  }
+
+  public async getS3UploadUrl(dto: AWSS3GetUploadDto): Promise<ITypedBackendResponse<AWSS3UploadUrl>> {
+    return this.execute<AWSS3UploadUrl>(
+      () => this.sdk.GetS3UploadUrl({ input: dto }),
+      'getUploadUrl',
+      (r) => r?.getUploadUrl?.uploadUrl !== undefined && r?.getUploadUrl?.uploadUrl !== null,
+      'getUploadUrl'
+    );
+  }
+
+  public async getVtxS3UploadUrl(dto: AWSS3GetUploadDto): Promise<ITypedBackendResponse<AWSS3UploadUrl>> {
+    return this.execute<AWSS3UploadUrl>(
+      () => this.sdk.GetVtxS3UploadUrl({ input: dto }),
+      'getS3UploadUrl',
+      (r) => r?.getS3UploadUrl?.uploadUrl !== undefined && r?.getS3UploadUrl?.uploadUrl !== null,
+      'getVtxS3UploadUrl'
+    );
+  }
+
+  public async refreshToken(currentToken: string, refreshToken: string): Promise<ITypedBackendResponse<UserToken>> {
+    const dto: RefreshTokenInput = { refreshToken };
+    return this.execute<UserToken>(
+      () => this.sdk.RefreshToken({ dto }),
+      'refreshToken',
+      (r) => !!r?.refreshToken?.refreshToken,
+      'refreshToken'
+    );
+  }
+
+  public async registerNewDomainTenant(input: CreateTenantInput): Promise<ITypedBackendResponse<Tenant>> {
+    return this.execute<Tenant>(
+      () => this.sdk.RegisterNewDomainTenant({ tenant: input }),
+      'registerNewDomainTenant',
+      (r) => !!r?.registerNewDomainTenant?._id,
+      'registerNewDomainTenant'
+    );
+  }
+
+  public async registerNewDomainTenantWithLogin(input: CreateTenantInput): Promise<ITypedBackendResponse<TenantWithUserLogin>> {
+    return this.execute<TenantWithUserLogin>(
+      () => this.sdk.RegisterNewDomainTenantWithLogin({ tenant: input }),
+      'TenantWithUserLogin',
+      (r) => !!r?.TenantWithUserLogin?._id,
+      'registerNewDomainTenantWithLogin'
+    );
+  }
+
+  public async registerUserToDomainFromEmail(input: RegisterUserToDomainFromEmailInput): Promise<ITypedBackendResponse<User>> {
+    return this.execute<User>(
+      () => this.sdk.RegisterUserToDomainFromEmail({ input }),
+      'registerUserToDomainFromEmail',
+      (r) => !!r?.registerUserToDomainFromEmail?.loginEmail,
+      'registerUserToDomainFromEmail'
+    );
+  }
+
+  public async getPublicSponsorships(): Promise<ITypedBackendResponse<Sponsorship[]>> {
+    return this.execute<Sponsorship[]>(
+      () => this.sdk.GetPublicSponsorships(),
+      'getPublicSponsorships',
+      (r) => Array.isArray(r?.getPublicSponsorships),
+      'getPublicSponsorships'
+    );
+  }
+
+  public async getTenantSponsorshipsFromUri(tenantUri: string, token: DecodedToken): Promise<ITypedBackendResponse<Sponsorship[]>> {
+    if ((!tenantUri) || (tenantUri.trim() === "")) {
+      return {
+        error: {
+          httpStatus: 400,
+          code: VTX_ERRORS.INVALID_TENANT_URI.code,
+          message: VTX_ERRORS.INVALID_TENANT_URI.description
+        }
+      };
+    }
+    const credential: DomainCredential | undefined = token.domains.find(c => {
+      if (c.tenant) {
+        if ((c.tenant.tenant_uri == tenantUri) && (c._id == DOMAIN_SPONSOR)) {
+          return true;
+        }
+      }
+      return false;
+    });
+    if (!credential) {
+      return {
+        error: {
+          httpStatus: 400,
+          code: VTX_ERRORS.INVALID_TENANT_URI_FOR_SPONSOR.code,
+          message: "Tenant in domain SPONSOR not found in domains with URI " + tenantUri
+        }
+      };
+    }
+    const tenantId: string | null = credential.tenant?._id ?? null;
+    if ((!tenantId) || (tenantId == "ALL")) {
+      return {
+        error: {
+          httpStatus: 400,
+          code: VTX_ERRORS.INVALID_TENANT_ID.code,
+          message: VTX_ERRORS.INVALID_TENANT_ID.description
+        }
+      };
+    }
+    return this.getTenantSponsorships(tenantId);
+  }
+
+  public async isUserSuspended(loginEmail: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.IsUserSuspended({ loginEmail }),
+      'isUserSuspended',
+      (r) => r?.isUserSuspended !== undefined,
+      'isUserSuspended'
+    );
+  }
+
+  public async getTenantSponsorships(tenantId: string): Promise<ITypedBackendResponse<Sponsorship[]>> {
+    return this.execute<Sponsorship[]>(
+      () => this.sdk.GetTenantSponsorships(),
+      'getTenantSponsorships',
+      (r) => Array.isArray(r?.getTenantSponsorships),
+      'getTenantSponsorships'
+    );
+  }
+
+  public async sendAthleteInvitations(input: InviteAthletesDto): Promise<ITypedBackendResponse<SponsorAthleteInvitation[]>> {
+    return this.execute<SponsorAthleteInvitation[]>(
+      () => this.sdk.SendAthleteInvitations({ input }),
+      'sendAthleteInvitations',
+      (r) => Array.isArray(r?.sendAthleteInvitations),
+      'sendAthleteInvitations'
+    );
+  }
+
+  public async registerSponsorUser(input: RegisterUserDto): Promise<ITypedBackendResponse<User>> {
+    return this.execute<User>(
+      () => this.sdk.RegisterSponsorUser({ input }),
+      'registerSponsorUser',
+      (r) => !!r?.registerSponsorUser?._id,
+      'registerSponsorUser'
+    );
+  }
+
+  public async registerAthleteUser(input: RegisterUserDto): Promise<ITypedBackendResponse<User>> {
+    return this.execute<User>(
+      () => this.sdk.RegisterAthleteUser({ input }),
+      'registerAthleteUser',
+      (r) => !!r?.registerAthleteUser?._id,
+      'registerAthleteUser'
+    );
+  }
+
+  public async preRegisterAthleteUser(input: RegisterUserDto): Promise<ITypedBackendResponse<VerificationCode>> {
+    return this.execute<VerificationCode>(
+      () => this.sdk.PreRegisterAthleteUser({ input }),
+      'preRegisterAthleteUser',
+      (r) => !!r?.preRegisterAthleteUser?._id,
+      'preRegisterAthleteUser'
+    );
+  }
+
+  public async confirmAthleteUserRegistrationAndLogin(input: VerifyCodeDto): Promise<ITypedBackendResponse<UserWithToken>> {
+    return this.execute<UserWithToken>(
+      () => this.sdk.ConfirmAthleteUserRegistrationAndLogin({ input }),
+      'confirmAthleteUserRegistrationAndLogin',
+      (r) => !!r?.confirmAthleteUserRegistrationAndLogin?._id,
+      'confirmAthleteUserRegistrationAndLogin'
+    );
+  }
+
+  public async confirmAthleteUserRegistration(input: VerifyCodeDto): Promise<ITypedBackendResponse<User>> {
+    return this.execute<User>(
+      () => this.sdk.ConfirmAthleteUserRegistration({ input }),
+      'confirmAthleteUserRegistration',
+      (r) => !!r?.confirmAthleteUserRegistration?._id,
+      'confirmAthleteUserRegistration'
+    );
+  }
+
+  public async findSponsorAthleteInvitation(dto: FindSponsorAthleteInvitationDto): Promise<ITypedBackendResponse<SponsorAthleteInvitation>> {
+    return this.execute<SponsorAthleteInvitation>(
+      () => this.sdk.FindSponsorAthleteInvitation({ input: dto }),
+      'findSponsorAthleteInvitation',
+      (r) => !!r?.findSponsorAthleteInvitation?._id,
+      'findSponsorAthleteInvitation'
+    );
+  }
+
+  public async findVtxUser(dto: FindVtxUserDto): Promise<ITypedBackendResponse<User>> {
+    return this.execute<User>(
+      () => this.sdk.FindVtxUser({ input: dto }),
+      'findVtxUser',
+      (r) => !!r?.findVtxUser?._id,
+      'findVtxUser'
+    );
+  }
+
+  public async findCitiesStartingWith(pattern: string): Promise<ITypedBackendResponse<City[]>> {
+    return this.execute<City[]>(
+      () => this.sdk.FindCitiesStartingWith({ text: pattern }),
+      'findCitiesStartingWith',
+      (r) => Array.isArray(r?.findCitiesStartingWith),
+      'findCitiesStartingWith'
+    );
+  }
+
+  public async findCityById(cityId: string): Promise<ITypedBackendResponse<City>> {
+    return this.execute<City>(
+      () => this.sdk.FindCityById({ cityId }),
+      'findCityById',
+      (r) => !!r?.findCityById?._id,
+      'findCityById'
+    );
+  }
+
+  public async getSportLevels(): Promise<ITypedBackendResponse<SportLevel[]>> {
+    return this.execute<SportLevel[]>(
+      () => this.sdk.GetSportLevels(),
+      'getSportLevels',
+      (r) => Array.isArray(r?.getSportLevels),
+      'getSportLevels'
+    );
+  }
+
+  public async getSports(): Promise<ITypedBackendResponse<Sport[]>> {
+    return this.execute<Sport[]>(
+      () => this.sdk.GetSports(),
+      'getSports',
+      (r) => Array.isArray(r?.getSports),
+      'getSports'
+    );
+  }
+
+  public async getSportsPaginated(args: { query: SportQueryDto }): Promise<ITypedBackendResponse<PaginatedSports>> {
+    return this.execute<PaginatedSports>(
+      () => this.sdk.GetSportsPaginated({ query: args.query }),
+      'getSportsPaginated',
+      (r) => true,
+      'getSportsPaginated'
+    );
+  }
+
+  public async getStates(): Promise<ITypedBackendResponse<State[]>> {
+    return this.execute<State[]>(
+      () => this.sdk.GetStates(),
+      'getStates',
+      (r) => Array.isArray(r?.getStates),
+      'getStates'
+    );
+  }
+
+  public async getCountries(): Promise<ITypedBackendResponse<Country[]>> {
+    return this.execute<Country[]>(
+      () => this.sdk.GetCountries(),
+      'getCountries',
+      (r) => Array.isArray(r?.getCountries),
+      'getCountries'
+    );
+  }
+
+  public async loginUserFromCredentialsVtx(username: string, password: string): Promise<ITypedBackendResponse<UserWithToken>> {
+    const curatedEmail = username.trim().toLocaleLowerCase();
+    return this.execute<UserWithToken>(
+      () => this.sdk.LoginUserFromCredentialsVtx({ username: curatedEmail, password }),
+      'loginUserFromCredentialsVtx',
+      (r) => !!r?.loginUserFromCredentialsVtx?.actualToken,
+      'loginUserFromCredentialsVtx'
+    );
+  }
+
+  public async validateUserCredentialsVtx(username: string, password: string): Promise<ITypedBackendResponse<User>> {
+    const curatedEmail = username.trim().toLocaleLowerCase();
+    return this.execute<User>(
+      () => this.sdk.ValidateUserCredentialsVtx({ username: curatedEmail, password }),
+      'validateUserCredentials',
+      (r) => !!r?.validateUserCredentials?._id,
+      'validateUserCredentials'
+    );
+  }
+
+  public async findAthleteForUser(loginEmail: string): Promise<ITypedBackendResponse<Athlete>> {
+    return this.execute<Athlete>(
+      () => this.sdk.FindAthleteForUser({ loginEmail }),
+      'findAthleteForUser',
+      (r) => !!r?.findAthleteForUser?._id,
+      'findAthleteForUser'
+    );
+  }
+
+  // ============= BRAND / ATHLETE LISTING METHODS =============
+
+  public async getBrands(): Promise<ITypedBackendResponse<Brand[]>> {
+    return this.execute<Brand[]>(
+      () => this.sdk.GetBrands(),
+      'brands',
+      (r) => Array.isArray(r?.brands),
+      'brands'
+    );
+  }
+
+  public async getBrandsPaginated(args: { query: BrandQueryDto }): Promise<ITypedBackendResponse<PaginatedBrands>> {
+    return this.execute<PaginatedBrands>(
+      () => this.sdk.GetBrandsPaginated({ query: args.query }),
+      'getBrandsPaginated',
+      (r) => true,
+      'getBrandsPaginated'
+    );
+  }
+
+  public async getAthletes(): Promise<ITypedBackendResponse<Athlete[]>> {
+    return this.execute<Athlete[]>(
+      () => this.sdk.GetAthletes(),
+      'athletes',
+      (r) => Array.isArray(r?.athletes),
+      'athletes'
+    );
+  }
+
+  public async searchAthletes(searchString: string): Promise<ITypedBackendResponse<Athlete[]>> {
+    return this.execute<Athlete[]>(
+      () => this.sdk.SearchAthletes({ searchString }),
+      'searchAthletes',
+      (r) => Array.isArray(r?.searchAthletes),
+      'searchAthletes'
+    );
+  }
+
+  public async getRecommendedAthletes(loginEmail: string): Promise<ITypedBackendResponse<Athlete[]>> {
+    return this.execute<Athlete[]>(
+      () => this.sdk.GetRecommendedAthletes({ loginEmail }),
+      'getRecommendedAthletes',
+      (r) => Array.isArray(r?.getRecommendedAthletes),
+      'getRecommendedAthletes'
+    );
+  }
+
+  public async getSponsorAthletesForTenant(): Promise<ITypedBackendResponse<Athlete[]>> {
+    return this.execute<Athlete[]>(
+      () => this.sdk.GetSponsorAthletesForTenant(),
+      'getSponsorAthletesForTenant',
+      (r) => Array.isArray(r?.getSponsorAthletesForTenant),
+      'getSponsorAthletesForTenant'
+    );
+  }
+
+  public async getUserImagesFromEmail(loginEmail: string): Promise<ITypedBackendResponse<UserImages>> {
+    return this.execute<UserImages>(
+      () => this.sdk.GetUserImagesFromEmail({ loginEmail }),
+      'getUserImagesFromEmail',
+      (r) => !!r?.getUserImagesFromEmail,
+      'getUserImagesFromEmail'
+    );
+  }
+
+  // ============= PROFILE EDIT METHODS =============
+
+  public async editAboutMe(newValue: string): Promise<ITypedBackendResponse<EditValueResponse>> {
+    const dto: EditValueDto = { field: 'aboutMe', newValue };
+    return this.execute<EditValueResponse>(
+      () => this.sdk.EditAboutMe({ input: dto }),
+      'editProfileValue',
+      (r) => !!r?.editProfileValue?.field,
+      'editProfileValue'
+    );
+  }
+
+  public async editProfileValue(newValue: string, field: string): Promise<ITypedBackendResponse<EditValueResponse>> {
+    const dto: EditValueDto = { field, newValue };
+    return this.execute<EditValueResponse>(
+      () => this.sdk.EditProfileValue({ input: dto }),
+      'editProfileValue',
+      (r) => !!r?.editProfileValue?.field,
+      'editProfileValue'
+    );
+  }
+
+  // ============= COMPETITION METHODS =============
+
+  public async addAthleteCompetition(dto: CreateAthleteCompetitionDto): Promise<ITypedBackendResponse<AthleteCompetition>> {
+    return this.execute<AthleteCompetition>(
+      () => this.sdk.AddAthleteCompetition({ input: dto }),
+      'addAthleteCompetition',
+      (r) => !!r?.addAthleteCompetition?._id,
+      'addAthleteCompetition'
+    );
+  }
+
+  public async getSportsEvents(dto: GetSportEventsDto): Promise<ITypedBackendResponse<SportsEvent[]>> {
+    return this.execute<SportsEvent[]>(
+      () => this.sdk.GetSportsEvents({ input: dto }),
+      'getSportsEvents',
+      (r) => Array.isArray(r?.getSportsEvents),
+      'getSportsEvents'
+    );
+  }
+
+  public async getSportsEventsPaginated(dto: { query: EventQueryDto }): Promise<ITypedBackendResponse<PaginatedEvents>> {
+    return this.execute<PaginatedEvents>(
+      () => this.sdk.GetSportsEventsPaginated({ query: dto.query }),
+      'getSportsEventsPaginated',
+      (r) => true,
+      'getSportsEventsPaginated'
+    );
+  }
+
+  public async createSportsEvent(dto: CreateSportEventDto): Promise<ITypedBackendResponse<SportsEvent>> {
+    return this.execute<SportsEvent>(
+      () => this.sdk.CreateSportsEvent({ input: dto }),
+      'createSportsEvent',
+      (r) => !!r?.createSportsEvent?._id,
+      'createSportsEvent'
+    );
+  }
+
+  public async updateSportsEvent(dto: { input: UpdateSportEventDto }): Promise<ITypedBackendResponse<SportsEvent>> {
+    return this.execute<SportsEvent>(
+      () => this.sdk.UpdateSportsEvent({ input: dto.input }),
+      'updateSportsEvent',
+      (r) => !!r?.updateSportsEvent?._id,
+      'updateSportsEvent'
+    );
+  }
+
+  public async deleteSportsEvent(dto: { eventId: string }): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.DeleteSportsEvent({ eventId: dto.eventId }),
+      'deleteSportsEvent',
+      (r) => !!r?.deleteSportsEvent?.idToDelete,
+      'deleteSportsEvent'
+    );
+  }
+
+  public async mergeSportsEvents(dto: MergeSportsEventsDto): Promise<ITypedBackendResponse<MergeEventsResponse>> {
+    return this.execute<MergeEventsResponse>(
+      () => this.sdk.MergeSportsEvents({ input: dto }),
+      'mergeSportsEvents',
+      (r) => !!r?.mergeSportsEvents,
+      'mergeSportsEvents'
+    );
+  }
+
+  public async getAthleteCompetitions(dto: GetAthleteCompetitionsDto): Promise<ITypedBackendResponse<AthleteCompetition[]>> {
+    return this.execute<AthleteCompetition[]>(
+      () => this.sdk.GetAthleteCompetitions({ input: dto }),
+      'getAthleteCompetitions',
+      (r) => Array.isArray(r?.getAthleteCompetitions),
+      'getAthleteCompetitions'
+    );
+  }
+
+  public async getAthleteMemberships(athleteId: string): Promise<ITypedBackendResponse<AthleteMembership[]>> {
+    return this.execute<AthleteMembership[]>(
+      () => this.sdk.GetAthleteMemberships({ athleteId }),
+      'getAthleteMemberships',
+      (r) => Array.isArray(r?.getAthleteMemberships),
+      'getAthleteMemberships'
+    );
+  }
+
+  public async deleteAthleteCompetition(dto: DeleteSingleValueDto): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.DeleteAthleteCompetition({ input: dto }),
+      'deleteAthleteCompetition',
+      (r) => !!r?.deleteAthleteCompetition?.idToDelete,
+      'deleteAthleteCompetition'
+    );
+  }
+
+  // ============= CAMPAIGN METHODS =============
+
+  public async createFundingCampaign(dto: CreateFundingCampaignDto): Promise<ITypedBackendResponse<FundRaisingCampaign>> {
+    return this.execute<FundRaisingCampaign>(
+      () => this.sdk.CreateFundingCampaign({ input: dto }),
+      'createFundingCampaign',
+      (r) => !!r?.createFundingCampaign?._id,
+      'createFundingCampaign'
+    );
+  }
+
+  public async createMembershipOrganization(dto: CreateMembershipOrganizationDto): Promise<ITypedBackendResponse<MembershipOrganizationReference>> {
+    return this.execute<MembershipOrganizationReference>(
+      () => this.sdk.CreateMembershipOrganization({ input: dto }),
+      'createMembershipOrganization',
+      (r) => !!r?.createMembershipOrganization?._id,
+      'createMembershipOrganization'
+    );
+  }
+
+  public async getMembershipOrganizations(): Promise<ITypedBackendResponse<MembershipOrganizationReference[]>> {
+    return this.execute<MembershipOrganizationReference[]>(
+      () => this.sdk.GetMembershipOrganizations(),
+      'getMembershipOrganizations',
+      (r) => Array.isArray(r?.getMembershipOrganizations),
+      'getMembershipOrganizations'
+    );
+  }
+
+  public async createAthleteMembershipAffilation(dto: CreateAthleteMembershipDto): Promise<ITypedBackendResponse<AthleteMembership>> {
+    return this.execute<AthleteMembership>(
+      () => this.sdk.CreateAthleteMembershipAffilation({ input: dto }),
+      'createAthleteMembershipAffilation',
+      (r) => !!r?.createAthleteMembershipAffilation?._id,
+      'createAthleteMembershipAffilation'
+    );
+  }
+
+  public async deleteMembershipAffiliation(dto: DeleteSingleValueDto): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.DeleteMembershipAffiliation({ input: dto }),
+      'deleteMembershipAffiliation',
+      (r) => !!r?.deleteMembershipAffiliation?.idToDelete,
+      'deleteMembershipAffiliation'
+    );
+  }
+
+  public async queryAthleteFundingCampaigns(dto: AthleteQueryDto): Promise<ITypedBackendResponse<AthleteQueryResponse>> {
+    return this.execute<AthleteQueryResponse>(
+      () => this.sdk.QueryAthleteFundingCampaigns({ input: dto }),
+      'queryAthleteFundingCampaigns',
+      (r) => !!r?.queryAthleteFundingCampaigns,
+      'queryAthleteFundingCampaigns'
+    );
+  }
+
+  // ============= STRIPE METHODS =============
+
+  public async createStripeAccount(dto: CreateStripeAccountDto): Promise<ITypedBackendResponse<StripeAccountReference>> {
+    return this.execute<StripeAccountReference>(
+      () => this.sdk.CreateStripeAccount({ input: dto }),
+      'createStripeAccount',
+      (r) => !!r?.createStripeAccount?._id,
+      'createStripeAccount'
+    );
+  }
+
+  public async createAthleteStripeSession(): Promise<ITypedBackendResponse<StripeSession>> {
+    return this.execute<StripeSession>(
+      () => this.sdk.CreateAthleteStripeSession(),
+      'createAthleteStripeSession',
+      (r) => !!r?.createAthleteStripeSession?.client_secret,
+      'createAthleteStripeSession'
+    );
+  }
+
+  public async createStripeCheckoutSession(dto: DonationCheckoutDto, _desiredFields?: any): Promise<ITypedBackendResponse<StripeCheckoutSession>> {
+    return this.execute<StripeCheckoutSession>(
+      () => this.sdk.CreateStripeCheckoutSession({ input: dto }),
+      'createStripeCheckoutSession',
+      (r) => !!r?.createStripeCheckoutSession?.client_secret,
+      'createStripeCheckoutSession'
+    );
+  }
+
+  public async createStripeLoginLink(): Promise<ITypedBackendResponse<string>> {
+    return this.execute<string>(
+      () => this.sdk.CreateStripeLoginLink(),
+      'createStripeLoginLink',
+      (r) => !!r?.createStripeLoginLink,
+      'createStripeLoginLink'
+    );
+  }
+
+  public async createStripeAccountLink(): Promise<ITypedBackendResponse<string>> {
+    return this.execute<string>(
+      () => this.sdk.CreateStripeAccountLink(),
+      'createStripeAccountLink',
+      (r) => !!r?.createStripeAccountLink,
+      'createStripeAccountLink'
+    );
+  }
+
+  public async getStripeBalance(): Promise<ITypedBackendResponse<StripeBalance>> {
+    return this.execute<StripeBalance>(
+      () => this.sdk.GetStripeBalance(),
+      'getStripeBalance',
+      (r) => r?.getStripeBalance?.availableUSD !== undefined,
+      'getStripeBalance'
+    );
+  }
+
+  public async getDatabaseTextFile(dto: GetDatabaseFileDto): Promise<ITypedBackendResponse<TextDatabaseFile>> {
+    return this.execute<TextDatabaseFile>(
+      () => this.sdk.GetDatabaseTextFile({ input: dto }),
+      'getDatabaseTextFile',
+      (r) => !!r?.getDatabaseTextFile?._id,
+      'getDatabaseTextFile'
+    );
+  }
+
+  public async getReceiptUrl(dto: GetReceiptDto): Promise<ITypedBackendResponse<ReceiptUrl>> {
+    return this.execute<ReceiptUrl>(
+      () => this.sdk.GetReceiptUrl({ input: dto }),
+      'getReceiptUrl',
+      (r) => !!r?.getReceiptUrl?.receiptId,
+      'getReceiptUrl'
+    );
+  }
+
+  public async stripeQuery(dto: StripeQueryDto): Promise<ITypedBackendResponse<StripeObject>> {
+    return this.execute<StripeObject>(
+      () => this.sdk.StripeQuery({ input: dto }),
+      'stripeQuery',
+      (r) => !!r?.stripeQuery,
+      'stripeQuery'
+    );
+  }
+
+  public async setFundingStatus(dto: SetFundingStatusDto, _desiredFields?: any): Promise<ITypedBackendResponse<FundRaisingCampaign>> {
+    return this.execute<FundRaisingCampaign>(
+      () => this.sdk.SetFundingStatus({ input: dto }),
+      'setFundingStatus',
+      (r) => !!r?.setFundingStatus?._id,
+      'setFundingStatus'
+    );
+  }
+
+  // ============= ATHLETE PUBLIC PROFILE =============
+
+  public async findAthleteForIdPublic(id: string): Promise<ITypedBackendResponse<Athlete>> {
+    return this.execute<Athlete>(
+      () => this.sdk.FindAthleteForIdPublic({ athleteId: id }),
+      'findAthletebyIdpublic',
+      (r) => !!r?.findAthletebyIdpublic?._id,
+      'findAthletebyIdpublic'
+    );
+  }
+
+  // ============= PICTURE / ALBUM METHODS =============
+
+  public async editPicture(newPicDto: EditPictureDto): Promise<ITypedBackendResponse<EditPictureResponse>> {
+    console.log('HEADERS:');
+    console.log(JSON.stringify(this.headers, null, 2));
+    return this.execute<EditPictureResponse>(
+      () => this.sdk.EditPicture({ input: newPicDto }),
+      'editPicture',
+      (r) => !!r?.editPicture?.field,
+      'editPicture'
+    );
+  }
+
+  public async addAlbumsPictures(dto: UploadAlbumsPicturesDto): Promise<ITypedBackendResponse<AddValuesResponse>> {
+    console.log('HEADERS:');
+    console.log(JSON.stringify(this.headers, null, 2));
+    let retValue: ITypedBackendResponse<AddValuesResponse> = {};
+    try {
+      const response: any = await this.sdk.AddAlbumPictures({ input: dto });
+      console.log('AddAlbumsPictures Response:');
+      console.log(JSON.stringify(response, null, 2));
+      retValue = buildResponse<AddValuesResponse>(response, 'AddAlbumPictures',
+        (r: any) => {
+          return r?.AddAlbumPictures?.result === 'success' || r?.AddAlbumPictures?.result === 'partial';
+        }
+      );
+    } catch (err1: any) {
+      console.error('addPictures err1:');
+      console.error(err1);
+      retValue = buildErrorResponse<AddValuesResponse>(err1);
+    }
+    console.log('retValue:');
+    console.log(JSON.stringify(retValue, null, 2));
+    return retValue;
+  }
+
+  public async editAlbumsPictures(dto: UploadAlbumsPicturesDto): Promise<ITypedBackendResponse<Album>> {
+    console.log('HEADERS:');
+    console.log(JSON.stringify(this.headers, null, 2));
+    let retValue: ITypedBackendResponse<Album> = {};
+    try {
+      const response: any = await this.sdk.EditAlbumsPictures({ input: dto });
+      console.log('editAlbum Response:');
+      console.log(JSON.stringify(response, null, 2));
+      retValue = buildResponse<Album>(response, 'editAlbum',
+        (r: any) => !!r?.editAlbum?.label
+      );
+    } catch (err1: any) {
+      console.error('editAlbum err1:');
+      console.error(err1);
+      retValue = buildErrorResponse<Album>(err1);
+    }
+    console.log('retValue:');
+    console.log(JSON.stringify(retValue, null, 2));
+    return retValue;
+  }
+
+  public async createAthleteAlbum(dto: UploadAlbumsPicturesDto): Promise<ITypedBackendResponse<Album>> {
+    console.log('HEADERS:');
+    console.log(JSON.stringify(this.headers, null, 2));
+    let retValue: ITypedBackendResponse<Album> = {};
+    try {
+      const response: any = await this.sdk.CreateAthleteAlbum({ input: dto });
+      console.log('createAthleteAlbum Response:');
+      console.log(JSON.stringify(response, null, 2));
+      retValue = buildResponse<Album>(response, 'createAthleteAlbum',
+        (r: any) => !!r?.createAthleteAlbum?.label
+      );
+    } catch (err1: any) {
+      console.error('createAthleteAlbum err1:');
+      console.error(err1);
+      retValue = buildErrorResponse<Album>(err1);
+    }
+    console.log('retValue:');
+    console.log(JSON.stringify(retValue, null, 2));
+    return retValue;
+  }
+
+  public async deleteFundingCampaign(dto: DeleteSingleValueDto): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.DeleteFundingCampaign({ input: dto }),
+      'deleteFundingCampaign',
+      (r) => !!r?.deleteFundingCampaign?.deleted,
+      'deleteFundingCampaign'
+    );
+  }
+
+  public async deleteFundingCampaigns(dto: DeleteValuesDto): Promise<ITypedBackendResponse<DeleteValuesResponse>> {
+    return this.execute<DeleteValuesResponse>(
+      () => this.sdk.DeleteFundingCampaigns({ input: dto }),
+      'deleteFundingCampaigns',
+      (r) => !!r?.deleteFundingCampaigns,
+      'deleteFundingCampaigns'
+    );
+  }
+
+  public async updateFundingCampaign(dto: UpdateFundingCampaignDto): Promise<ITypedBackendResponse<FundRaisingCampaign>> {
+    return this.execute<FundRaisingCampaign>(
+      () => this.sdk.UpdateFundingCampaign({ input: dto }),
+      'updateFundingCampaign',
+      (r) => !!r?.updateFundingCampaign?._id,
+      'updateFundingCampaign'
+    );
+  }
+
+  public async setCurrentCampaign(dto: SetCurrentCampaignDto): Promise<ITypedBackendResponse<FundRaisingCampaign>> {
+    return this.execute<FundRaisingCampaign>(
+      () => this.sdk.SetCurrentCampaign({ input: dto }),
+      'setCurrentCampaign',
+      (r) => !!r?.setCurrentCampaign?._id,
+      'setCurrentCampaign'
+    );
+  }
+
+  public async deleteAthleteAlbum(dto: DeleteSingleValueDto): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.DeleteAthleteAlbum({ input: dto }),
+      'deleteAthleteAlbum',
+      (r) => !!r?.deleteAthleteAlbum?.deleted,
+      'deleteAthleteAlbum'
+    );
+  }
+
+  public async getAthleteAlbums(): Promise<ITypedBackendResponse<Album[]>> {
+    return this.execute<Album[]>(
+      () => this.sdk.GetAthleteAlbums(),
+      'getAthleteAlbums',
+      (r) => Array.isArray(r?.getAthleteAlbums),
+      'getAthleteAlbums'
+    );
+  }
+
+  public async reorderAlbums(dto: EditDisplayIndexDto): Promise<ITypedBackendResponse<Album[]>> {
+    return this.execute<Album[]>(
+      () => this.sdk.ReorderAlbums({ input: dto }),
+      'reorderAlbumIndex',
+      (r) => r?.reorderAlbumIndex?.length > 0,
+      'reorderAlbumIndex'
+    );
+  }
+
+  public async getPublicAthleteAlbums(athleteId: string): Promise<ITypedBackendResponse<Album[]>> {
+    return this.execute<Album[]>(
+      () => this.sdk.GetPublicAthleteAlbums({ athleteId }),
+      'getPublicAthleteAlbums',
+      (r) => r?.getPublicAthleteAlbums?.length > 0,
+      'getPublicAthleteAlbums'
+    );
+  }
+
+  public async getAthleteAlbumsById(albumId: string): Promise<ITypedBackendResponse<Album>> {
+    return this.execute<Album>(
+      () => this.sdk.GetAthleteAlbumsById({ input: albumId }),
+      'getAthleteAlbumId',
+      (r) => !!r?.getAthleteAlbumId?._id,
+      'getAthleteAlbumId'
+    );
+  }
+
+  public async getAndSetAlbumById(albumId: string): Promise<ITypedBackendResponse<Album>> {
+    return this.execute<Album>(
+      () => this.sdk.GetAndSetAlbumById({ input: albumId }),
+      'getAndSetAlbumById',
+      (r) => !!r?.getAndSetAlbumById?._id,
+      'getAndSetAlbumById'
+    );
+  }
+
+  public async queryAthletesWithFilters(dto: AthleteQueryDto): Promise<ITypedBackendResponse<AthleteQueryResponse>> {
+    return this.execute<AthleteQueryResponse>(
+      () => this.sdk.QueryAthletesWithFilters({ input: dto }),
+      'queryAthletesWithFilters',
+      (r) => !!r?.queryAthletesWithFilters,
+      'queryAthletesWithFilters'
+    );
+  }
+
+  // ============= INTEGRATION METHODS =============
+
+  public async getAthleteIntegrationsByAthlete(): Promise<ITypedBackendResponse<AthleteIntegrationReference>> {
+    return this.execute<AthleteIntegrationReference>(
+      () => this.sdk.GetAthleteIntegrationsByAthlete(),
+      'getAthleteIntegrationsByAthlete',
+      (r) => !!r?.getAthleteIntegrationsByAthlete,
+      'getAthleteIntegrationsByAthlete'
+    );
+  }
+
+  public async deleteAthleteIntegration(): Promise<ITypedBackendResponse<boolean>> {
+    // NOTE: This method is commented out in the old vtx-base-api.ts and excluded from integrations.graphql
+    return { error: { httpStatus: 501, code: 0, message: 'deleteAthleteIntegration not implemented' } };
+  }
+
+  public async getAthleteStravaIntegration(): Promise<ITypedBackendResponse<AthleteIntegrationReference>> {
+    return this.execute<AthleteIntegrationReference>(
+      () => this.sdk.GetAthleteStravaIntegration(),
+      'getAthleteStravaIntegration',
+      (r) => !!r?.getAthleteStravaIntegration,
+      'getAthleteStravaIntegration'
+    );
+  }
+
+  public async getAthleteInstagramIntegration(): Promise<ITypedBackendResponse<AthleteIntegrationReference>> {
+    return this.execute<AthleteIntegrationReference>(
+      () => this.sdk.GetAthleteInstagramIntegration(),
+      'getAthleteInstagramIntegration',
+      (r) => !!r?.getAthleteInstagramIntegration,
+      'getAthleteInstagramIntegration'
+    );
+  }
+
+  public async getReceipt(dto: GetReceiptDto): Promise<ITypedBackendResponse<Receipt>> {
+    return this.execute<Receipt>(
+      () => this.sdk.GetReceipt({ input: dto }),
+      'getReceipt',
+      (r) => !!r?.getReceipt?._id,
+      'getReceipt'
+    );
+  }
+
+  public async getAthleteIntegrations(): Promise<ITypedBackendResponse<AthleteIntegrationReference>> {
+    return this.execute<AthleteIntegrationReference>(
+      () => this.sdk.GetAthleteIntegrations(),
+      'getAthleteIntegrations',
+      (r) => !!r?.getAthleteIntegrations,
+      'getAthleteIntegrations'
+    );
+  }
+
+  public async getAthleteCampaigns(dto: GetAthleteCampaignsDto): Promise<ITypedBackendResponse<FundRaisingCampaign[]>> {
+    return this.execute<FundRaisingCampaign[]>(
+      () => this.sdk.GetAthleteCampaigns({ input: dto }),
+      'getAthleteCampaigns',
+      (r) => Array.isArray(r?.getAthleteCampaigns),
+      'getAthleteCampaigns'
+    );
+  }
+
+  public async browseCampaigns(dto: BrowseCampaignsDto): Promise<ITypedBackendResponse<BrowseCampaignsResult>> {
+    return this.execute<BrowseCampaignsResult>(
+      () => this.sdk.BrowseCampaigns({ input: dto }),
+      'browseCampaigns',
+      (r) => !!r?.browseCampaigns,
+      'browseCampaigns'
+    );
+  }
+
+  public async updateAthleteIntegration(type: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.UpdateAthleteIntegration({ type }),
+      'updateAthleteIntegration',
+      (r) => r?.updateAthleteIntegration === true,
+      'updateAthleteIntegration'
+    );
+  }
+
+  public async deleteUploadedTypeKeyFile(dto: AWSS3DeleteUseTypeKeyDto): Promise<ITypedBackendResponse<AWSS3CallResult>> {
+    return this.execute<AWSS3CallResult>(
+      () => this.sdk.DeleteUploadedTypeKeyFile({ input: dto }),
+      'deleteUploadedTypeKeyFile',
+      (r) => !!r?.deleteUploadedTypeKeyFile?.httpStatus,
+      'deleteUploadedTypeKeyFile'
+    );
+  }
+
+  public async saveAthleteCompetitionResult(dto: SetCompetitionResultDto): Promise<ITypedBackendResponse<AthleteCompetitionResult>> {
+    return this.execute<AthleteCompetitionResult>(
+      () => this.sdk.SaveAthleteCompetitionResult({ input: dto }),
+      'saveAthleteCompetitionResult',
+      (r) => !!r?.saveAthleteCompetitionResult?._id,
+      'saveAthleteCompetitionResult'
+    );
+  }
+
+  // ============= SCORE METHODS =============
+
+  public async updateAthleteScores(): Promise<ITypedBackendResponse<Athlete>> {
+    return this.execute<Athlete>(
+      () => this.sdk.UpdateAthleteScores(),
+      'updateAthleteScores',
+      (r) => !!r?.updateAthleteScores?._id,
+      'updateAthleteScores'
+    );
+  }
+
+  public async updateAthleteCompetitionScores(): Promise<ITypedBackendResponse<Athlete>> {
+    return this.execute<Athlete>(
+      () => this.sdk.UpdateAthleteCompetitionScores(),
+      'updateAthleteCompetitionScores',
+      (r) => !!r?.updateAthleteCompetitionScores?._id,
+      'updateAthleteCompetitionScores'
+    );
+  }
+
+  public async forceRefreshAthleteScores(
+    athleteIds: string[],
+    options?: { rebuildHistorical?: boolean; historicalDays?: number }
+  ): Promise<ITypedBackendResponse<ForceScoreRefreshResponse>> {
+    return this.execute<ForceScoreRefreshResponse>(
+      () => this.sdk.ForceRefreshAthleteScores({ input: { athleteIds } }),
+      'forceRefreshAthleteScores',
+      (r) => !!r?.forceRefreshAthleteScores,
+      'forceRefreshAthleteScores'
+    );
+  }
+
+  public async checkScoreRefreshCapabilities(input: { athleteIds: string[] }): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.CheckScoreRefreshCapabilities({ input }),
+      'checkScoreRefreshCapabilities',
+      (r) => !!r?.checkScoreRefreshCapabilities,
+      'checkScoreRefreshCapabilities'
+    );
+  }
+
+  // ============= PASSWORD / VERIFICATION METHODS =============
+
+  public async createResetPasswordCode(email: string): Promise<ITypedBackendResponse<EditValueResponse>> {
+    return this.execute<EditValueResponse>(
+      () => this.sdk.CreateResetPasswordCode({ input: email }),
+      'createResetPasswordCode',
+      (r) => r?.createResetPasswordCode?.field !== null,
+      'createResetPasswordCode'
+    );
+  }
+
+  public async getResetVerificationCode(id: string): Promise<ITypedBackendResponse<VerificationCodeType>> {
+    return this.execute<VerificationCodeType>(
+      () => this.sdk.GetResetVerificationCode({ input: id }),
+      'getResetVerificationCode',
+      (r) => !!r?.getResetVerificationCode?.changed,
+      'getResetVerificationCode'
+    );
+  }
+
+  public async verifyCode(input: VerifyCodeDto): Promise<ITypedBackendResponse<CodeVerificationResponse>> {
+    return this.execute<CodeVerificationResponse>(
+      () => this.sdk.VerifyCode({ input }),
+      'verifyCode',
+      (r) => r?.verifyCode?.result === 'success' || r?.verifyCode?.result === 'error',
+      'verifyCode'
+    );
+  }
+
+  public async resetUserPassword(input: resetPasswordDto): Promise<ITypedBackendResponse<EditValueResponse>> {
+    return this.execute<EditValueResponse>(
+      () => this.sdk.ResetUserPassword({ input }),
+      'resetUserPassword',
+      (r) => r?.resetUserPassword?.field !== null,
+      'resetUserPassword'
+    );
+  }
+
+  public async deleteAlbumFotos(dto: DeleteValuesDto): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.DeleteAlbumFotos({ input: dto }),
+      'deleteAlbumFotos',
+      (r) => !!r?.deleteAlbumFotos?.deleted,
+      'deleteAlbumFotos'
+    );
+  }
+
+  public async screenNameAviability(dto: existValueDto): Promise<ITypedBackendResponse<ExistValueResponse>> {
+    return this.execute<ExistValueResponse>(
+      () => this.sdk.ScreenNameAvailability({ input: dto }),
+      'screenNameAviability',
+      (r) => r?.screenNameAviability !== undefined,
+      'screenNameAviability'
+    );
+  }
+
+  // ============= BUDGET METHODS =============
+
+  public async getBudgetsByAthlete(): Promise<ITypedBackendResponse<BudgetData>> {
+    return this.execute<BudgetData>(
+      () => this.sdk.GetBudgetsByAthlete(),
+      'getBudgetsByAthlete',
+      (r) => !!r?.getBudgetsByAthlete,
+      'getBudgetsByAthlete'
+    );
+  }
+
+  public async deleteCompetitionBudget(competitionId: string): Promise<ITypedBackendResponse<Boolean>> {
+    return this.execute<Boolean>(
+      () => this.sdk.DeleteCompetitionBudget({ competitionId }),
+      'deleteCompetitionBudget',
+      (r) => r?.deleteCompetitionBudget !== undefined,
+      'deleteCompetitionBudget'
+    );
+  }
+
+  public async addCompetitionBudget(input: AddCompetitionBudgetDto): Promise<ITypedBackendResponse<Boolean>> {
+    return this.execute<Boolean>(
+      () => this.sdk.AddCompetitionBudget({ input }),
+      'addCompetitionBudget',
+      (r) => r?.addCompetitionBudget !== undefined,
+      'addCompetitionBudget'
+    );
+  }
+
+  public async editCompetitionBudget(input: EditCompetitionBudgetDto): Promise<ITypedBackendResponse<Boolean>> {
+    return this.execute<Boolean>(
+      () => this.sdk.EditCompetitionBudget({ input }),
+      'editCompetitionBudget',
+      (r) => r?.editCompetitionBudget !== undefined,
+      'editCompetitionBudget'
+    );
+  }
+
+  public async editCampaignBudget(input: EditCampaignBudgetDto): Promise<ITypedBackendResponse<Boolean>> {
+    return this.execute<Boolean>(
+      () => this.sdk.EditCampaignBudget({ input }),
+      'editCampaignBudget',
+      (r) => r?.editCampaignBudget !== undefined,
+      'editCampaignBudget'
+    );
+  }
+
+  public async editCompetitionBudgetForCampaign(input: EditCampaignBudgetDto): Promise<ITypedBackendResponse<Boolean>> {
+    return this.execute<Boolean>(
+      () => this.sdk.EditCompetitionBudgetForCampaign({ input }),
+      'editCompetitionBudgetForCampaign',
+      (r) => r?.editCompetitionBudgetForCampaign !== undefined,
+      'editCompetitionBudgetForCampaign'
+    );
+  }
+
+  // ============= DONATION METHODS =============
+
+  public async getDonationsByAthlete(): Promise<ITypedBackendResponse<Receipt[]>> {
+    return this.execute<Receipt[]>(
+      () => this.sdk.GetDonationsByAthlete(),
+      'getDonationsByAthlete',
+      (r) => Array.isArray(r?.getDonationsByAthlete),
+      'getDonationsByAthlete'
+    );
+  }
+
+  public async getDonationsByMember(): Promise<ITypedBackendResponse<Donation[]>> {
+    return this.execute<Donation[]>(
+      () => this.sdk.GetDonationsByMember(),
+      'getDonationsByMember',
+      (r) => Array.isArray(r?.getDonationsByMember),
+      'getDonationsByMember'
+    );
+  }
+
+  public async findMemberForUser(loginEmail: string): Promise<ITypedBackendResponse<Member>> {
+    return this.execute<Member>(
+      () => this.sdk.FindMemberForUser({ loginEmail }),
+      'findMemberForUser',
+      (r) => !!r?.findMemberForUser?._id,
+      'findMemberForUser'
+    );
+  }
+
+  public async getBudgetConcepts(): Promise<ITypedBackendResponse<BudgetConcept[]>> {
+    return this.execute<BudgetConcept[]>(
+      () => this.sdk.GetBudgetConcepts(),
+      'getBudgetConcepts',
+      (r) => Array.isArray(r?.getBudgetConcepts),
+      'getBudgetConcepts'
+    );
+  }
+
+  public async getBudgetItemsUnits(): Promise<ITypedBackendResponse<BudgetItemUnit[]>> {
+    return this.execute<BudgetItemUnit[]>(
+      () => this.sdk.GetBudgetItemsUnits(),
+      'getBudgetItemsUnits',
+      (r) => Array.isArray(r?.getBudgetItemsUnits),
+      'getBudgetItemsUnits'
+    );
+  }
+
+  public async verifyAthleteCompetitionLinkedForDelete(dto: existValueDto): Promise<ITypedBackendResponse<CompetitionDeleteVerificationResponse>> {
+    return this.execute<CompetitionDeleteVerificationResponse>(
+      () => this.sdk.VerifyAthleteCompetitionLinkedForDelete({ input: dto }),
+      'verifyAthleteCompetitionLinkedForDelete',
+      (r) => r?.verifyAthleteCompetitionLinkedForDelete !== undefined,
+      'verifyAthleteCompetitionLinkedForDelete'
+    );
+  }
+
+  public async forceDeleteAthleteCompetition(dto: DeleteSingleValueDto): Promise<ITypedBackendResponse<DeleteSingleValueResponse>> {
+    return this.execute<DeleteSingleValueResponse>(
+      () => this.sdk.ForceDeleteAthleteCompetition({ input: dto }),
+      'forceDeleteAthleteCompetition',
+      (r) => !!r?.forceDeleteAthleteCompetition?.idToDelete,
+      'forceDeleteAthleteCompetition'
+    );
+  }
+
+  public async registerUser(input: RegisterUserDto): Promise<ITypedBackendResponse<User>> {
+    return this.execute<User>(
+      () => this.sdk.RegisterUser({ input }),
+      'registerUser',
+      (r) => !!r?.registerUser?._id,
+      'registerUser'
+    );
+  }
+
+  public async getDonationsToAthlete(athleteId: string): Promise<ITypedBackendResponse<Donation[]>> {
+    return this.execute<Donation[]>(
+      () => this.sdk.GetDonationsToAthlete({ athleteId }),
+      'getDonationsToAthlete',
+      (r) => Array.isArray(r?.getDonationsToAthlete),
+      'getDonationsToAthlete'
+    );
+  }
+
+  public async getDonationsToMe(): Promise<ITypedBackendResponse<Donation[]>> {
+    return this.execute<Donation[]>(
+      () => this.sdk.GetDonationsToMe(),
+      'getDonationsToMe',
+      (r) => Array.isArray(r?.getDonationsToMe),
+      'getDonationsToMe'
+    );
+  }
+
+  public async getDonationDatesForCalendar(campaignId?: string): Promise<ITypedBackendResponse<DonationDates>> {
+    return this.execute<DonationDates>(
+      () => this.sdk.GetDonationDatesForCalendar({ campaignId }),
+      'getDonationDatesForCalendar',
+      (r) => !!r?.getDonationDatesForCalendar,
+      'getDonationDatesForCalendar'
+    );
+  }
+
+  public async getDonationsPaginated(query?: DonationQueryDto): Promise<ITypedBackendResponse<PaginatedDonations>> {
+    return this.execute<PaginatedDonations>(
+      () => this.sdk.GetDonationsPaginated({ query }),
+      'getDonationsPaginated',
+      (r) => !!r?.getDonationsPaginated,
+      'getDonationsPaginated'
+    );
+  }
+
+  // ============= HISTORICAL SCORE METHODS =============
+
+  public async getAthleteHistoricalScores(dto: GetHistoricalScoresDto): Promise<ITypedBackendResponse<HistoricalScore[]>> {
+    return this.execute<HistoricalScore[]>(
+      () => this.sdk.GetAthleteHistoricalScores({ input: dto }),
+      'getAthleteHistoricalScores',
+      (r) => Array.isArray(r?.getAthleteHistoricalScores),
+      'getAthleteHistoricalScores'
+    );
+  }
+
+  public async getMyHistoricalScores(dto: GetMyHistoricalScoresDto): Promise<ITypedBackendResponse<HistoricalScore[]>> {
+    return this.execute<HistoricalScore[]>(
+      () => this.sdk.GetMyHistoricalScores({ input: dto }),
+      'getMyHistoricalScores',
+      (r) => Array.isArray(r?.getMyHistoricalScores),
+      'getMyHistoricalScores'
+    );
+  }
+
+  public async getAthleteHistoricalScoresPeriod(dto: GetHistoricalScoresDto): Promise<ITypedBackendResponse<HistoricalScoresPeriod>> {
+    return this.execute<HistoricalScoresPeriod>(
+      () => this.sdk.GetAthleteHistoricalScoresPeriod({ input: dto }),
+      'getAthleteHistoricalScoresPeriod',
+      (r) => !!r?.getAthleteHistoricalScoresPeriod,
+      'getAthleteHistoricalScoresPeriod'
+    );
+  }
+
+  public async getMyHistoricalScoresPeriod(dto: GetMyHistoricalScoresDto): Promise<ITypedBackendResponse<HistoricalScoresPeriod>> {
+    return this.execute<HistoricalScoresPeriod>(
+      () => this.sdk.GetMyHistoricalScoresPeriod({ input: dto }),
+      'getMyHistoricalScoresPeriod',
+      (r) => !!r?.getMyHistoricalScoresPeriod,
+      'getMyHistoricalScoresPeriod'
+    );
+  }
+
+  // ============= ADMIN METHODS =============
+
+  public async getTransactionDetails(dto: GetTransactionDetailsDto): Promise<ITypedBackendResponse<TransactionDetails>> {
+    return this.execute<TransactionDetails>(
+      () => this.sdk.GetTransactionDetails({ input: dto }),
+      'getTransactionDetails',
+      (r) => !!r?.getTransactionDetails,
+      'getTransactionDetails'
+    );
+  }
+
+  public async getAllUsers(): Promise<ITypedBackendResponse<AdminUserView[]>> {
+    return this.execute<AdminUserView[]>(
+      () => this.sdk.GetAllUsers(),
+      'getAllUsers',
+      (r) => Array.isArray(r?.getAllUsers),
+      'getAllUsers'
+    );
+  }
+
+  public async getAllTransactions(): Promise<ITypedBackendResponse<AdminTransactionView[]>> {
+    return this.execute<AdminTransactionView[]>(
+      () => this.sdk.GetAllTransactions(),
+      'getAllTransactions',
+      (r) => Array.isArray(r?.getAllTransactions),
+      'getAllTransactions'
+    );
+  }
+
+  public async getTransactionsPaginated(args: { query?: TransactionQueryDto } = {}): Promise<ITypedBackendResponse<PaginatedTransactions>> {
+    return this.execute<PaginatedTransactions>(
+      () => this.sdk.GetTransactionsPaginated({ query: args.query }),
+      'getTransactionsPaginated',
+      (r) => true,
+      'getTransactionsPaginated'
+    );
+  }
+
+  public async getUsersPaginated(args: { query: UserQueryDto }): Promise<ITypedBackendResponse<PaginatedUsers>> {
+    return this.execute<PaginatedUsers>(
+      () => this.sdk.GetUsersPaginated({ query: args.query }),
+      'getUsersPaginated',
+      (r) => true,
+      'getUsersPaginated'
+    );
+  }
+
+  public async updateUserSuspendedStatus(dto: UpdateUserSuspendedStatusDto): Promise<ITypedBackendResponse<EditValueResponse>> {
+    return this.execute<EditValueResponse>(
+      () => this.sdk.UpdateUserSuspendedStatus({ input: dto }),
+      'updateUserSuspendedStatus',
+      (r) => r?.updateUserSuspendedStatus?.field !== null,
+      'updateUserSuspendedStatus'
+    );
+  }
+
+  public async deleteVtxUser(dto: DeleteVtxUserDto): Promise<ITypedBackendResponse<DeleteVtxUserResponse>> {
+    return this.execute<DeleteVtxUserResponse>(
+      () => this.sdk.DeleteVtxUser({ input: dto }),
+      'deleteVtxUser',
+      (r) => r?.deleteVtxUser?.success !== undefined,
+      'deleteVtxUser'
+    );
+  }
+
+  public async deleteMyAccount(): Promise<ITypedBackendResponse<DeleteVtxUserResponse>> {
+    return this.execute<DeleteVtxUserResponse>(
+      () => this.sdk.DeleteMyAccount(),
+      'deleteMyAccount',
+      (r) => r?.deleteMyAccount?.success !== undefined,
+      'deleteMyAccount'
+    );
+  }
+
+  // ============= OFFER METHODS =============
+
+  public async createOffer(dto: CreateOfferDto): Promise<ITypedBackendResponse<Offer>> {
+    return this.execute<Offer>(
+      () => this.sdk.CreateOffer({ input: dto }),
+      'createOffer',
+      (r) => !!r?.createOffer?._id,
+      'createOffer'
+    );
+  }
+
+  public async getOffers(): Promise<ITypedBackendResponse<Offer[]>> {
+    return this.execute<Offer[]>(
+      () => this.sdk.GetOffers(),
+      'getOffers',
+      (r) => Array.isArray(r?.getOffers),
+      'getOffers'
+    );
+  }
+
+  public async getOffersPaginated(args: { query: OfferQueryDto }): Promise<ITypedBackendResponse<PaginatedOffers>> {
+    return this.execute<PaginatedOffers>(
+      () => this.sdk.GetOffersPaginated({ query: args.query }),
+      'getOffersPaginated',
+      (r) => true,
+      'getOffersPaginated'
+    );
+  }
+
+  public async getOffersWithEligibility(args: { query?: OfferQueryDto }): Promise<ITypedBackendResponse<PaginatedOffersWithEligibility>> {
+    return this.execute<PaginatedOffersWithEligibility>(
+      () => this.sdk.OffersWithEligibility({ query: args.query }),
+      'offersWithEligibility',
+      (r) => true,
+      'offersWithEligibility'
+    );
+  }
+
+  public async getOfferById(id: string): Promise<ITypedBackendResponse<Offer>> {
+    return this.execute<Offer>(
+      () => this.sdk.GetOfferById({ id }),
+      'getOfferById',
+      (r) => !!r?.getOfferById?._id,
+      'getOfferById'
+    );
+  }
+
+  public async getOffersForAthlete(athleteId: string | null): Promise<ITypedBackendResponse<Offer[]>> {
+    return this.execute<Offer[]>(
+      () => this.sdk.GetOffersForAthlete({ athleteId }),
+      'getOffersForAthlete',
+      (r) => Array.isArray(r?.getOffersForAthlete),
+      'getOffersForAthlete'
+    );
+  }
+
+  public async updateOffer(id: string, dto: CreateOfferDto): Promise<ITypedBackendResponse<Offer>> {
+    return this.execute<Offer>(
+      () => this.sdk.UpdateOffer({ id, input: dto }),
+      'updateOffer',
+      (r) => !!r?.updateOffer?._id,
+      'updateOffer'
+    );
+  }
+
+  public async deleteOffer(id: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.DeleteOffer({ id }),
+      'deleteOffer',
+      (r) => r?.deleteOffer === true,
+      'deleteOffer'
+    );
+  }
+
+  public async setOfferStatus(id: string, status: string): Promise<ITypedBackendResponse<Offer>> {
+    return this.execute<Offer>(
+      () => this.sdk.SetOfferStatus({ id, status }),
+      'setOfferStatus',
+      (r) => !!r?.setOfferStatus?._id,
+      'setOfferStatus'
+    );
+  }
+
+  public async activateOffer(id: string): Promise<ITypedBackendResponse<Offer>> {
+    return this.execute<Offer>(
+      () => this.sdk.ActivateOffer({ id }),
+      'activateOffer',
+      (r) => !!r?.activateOffer?._id,
+      'activateOffer'
+    );
+  }
+
+  public async deactivateOffer(id: string): Promise<ITypedBackendResponse<Offer>> {
+    return this.execute<Offer>(
+      () => this.sdk.DeactivateOffer({ id }),
+      'deactivateOffer',
+      (r) => !!r?.deactivateOffer?._id,
+      'deactivateOffer'
+    );
+  }
+
+  public async uploadCouponCodes(offerId: string, csvContent: string): Promise<ITypedBackendResponse<UploadResult>> {
+    return this.execute<UploadResult>(
+      () => this.sdk.UploadCouponCodes({ offerId, csvContent }),
+      'uploadCouponCodes',
+      (r) => !!r?.uploadCouponCodes,
+      'uploadCouponCodes'
+    );
+  }
+
+  public async claimOffer(offerId: string, athleteId: string): Promise<ITypedBackendResponse<OfferClaim>> {
+    return this.execute<OfferClaim>(
+      () => this.sdk.ClaimOffer({ offerId, athleteId }),
+      'claimOffer',
+      (r) => !!r?.claimOffer?._id,
+      'claimOffer'
+    );
+  }
+
+  public async getMyOfferClaims(args: { athleteId: string, query?: OfferClaimQueryDto }): Promise<ITypedBackendResponse<OfferClaim[]>> {
+    return this.execute<OfferClaim[]>(
+      () => this.sdk.GetMyOfferClaims({ athleteId: args.athleteId, query: args.query }),
+      'getMyOfferClaims',
+      (r) => Array.isArray(r?.getMyOfferClaims),
+      'getMyOfferClaims'
+    );
+  }
+
+  public async removeOfferClaim(claimId: string, athleteId: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.RemoveOfferClaim({ claimId, athleteId }),
+      'removeOfferClaim',
+      (r) => r?.removeOfferClaim === true,
+      'removeOfferClaim'
+    );
+  }
+
+  public async updateBrand(id: string, dto: CreateBrandDto): Promise<ITypedBackendResponse<Brand>> {
+    return this.execute<Brand>(
+      () => this.sdk.UpdateBrand({ id, input: dto }),
+      'updateBrand',
+      (r) => !!r?.updateBrand?._id,
+      'updateBrand'
+    );
+  }
+
+  public async deleteBrand(id: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.DeleteBrand({ id }),
+      'deleteBrand',
+      (r) => r?.deleteBrand === true,
+      'deleteBrand'
+    );
+  }
+
+  public async linkBrandToSponsor(brandId: string, sponsorId: string): Promise<ITypedBackendResponse<Brand>> {
+    return this.execute<Brand>(
+      () => this.sdk.LinkBrandToSponsor({ brandId, sponsorId }),
+      'linkBrandToSponsor',
+      (r) => !!r?.linkBrandToSponsor?._id,
+      'linkBrandToSponsor'
+    );
+  }
+
+  public async unlinkBrandFromSponsor(brandId: string, sponsorId: string): Promise<ITypedBackendResponse<Brand>> {
+    return this.execute<Brand>(
+      () => this.sdk.UnlinkBrandFromSponsor({ brandId, sponsorId }),
+      'unlinkBrandFromSponsor',
+      (r) => !!r?.unlinkBrandFromSponsor?._id,
+      'unlinkBrandFromSponsor'
+    );
+  }
+
+  // ============= SPONSOR METHODS =============
+
+  public async getSponsors(): Promise<ITypedBackendResponse<Sponsor[]>> {
+    return this.execute<Sponsor[]>(
+      () => this.sdk.GetSponsors(),
+      'getSponsors',
+      (r) => Array.isArray(r?.getSponsors),
+      'getSponsors'
+    );
+  }
+
+  public async getSponsorsPaginated(args: { query: SponsorQueryDto }): Promise<ITypedBackendResponse<PaginatedSponsors>> {
+    return this.execute<PaginatedSponsors>(
+      () => this.sdk.GetSponsorsPaginated({ query: args.query }),
+      'getSponsorsPaginated',
+      (r) => true,
+      'getSponsorsPaginated'
+    );
+  }
+
+  public async createSponsor(dto: CreateSponsorDto): Promise<ITypedBackendResponse<Sponsor>> {
+    return this.execute<Sponsor>(
+      () => this.sdk.CreateSponsor({ input: dto }),
+      'createSponsor',
+      (r) => !!r?.createSponsor?._id,
+      'createSponsor'
+    );
+  }
+
+  public async updateSponsor(id: string, dto: CreateSponsorDto): Promise<ITypedBackendResponse<Sponsor>> {
+    return this.execute<Sponsor>(
+      () => this.sdk.UpdateSponsor({ id, input: dto as any }),
+      'updateSponsor',
+      (r) => !!r?.updateSponsor?._id,
+      'updateSponsor'
+    );
+  }
+
+  public async deleteSponsor(id: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.DeleteSponsor({ id }),
+      'deleteSponsor',
+      (r) => r?.deleteSponsor === true,
+      'deleteSponsor'
+    );
+  }
+
+  // ============= LEADERBOARD METHODS =============
+
+  public async getLeaderboard(args?: { input?: LeaderboardQueryDto }): Promise<ITypedBackendResponse<LeaderboardResponse>> {
+    return this.execute<LeaderboardResponse>(
+      () => this.sdk.GetLeaderboard({ input: args?.input }),
+      'getLeaderboard',
+      (r) => !!r?.getLeaderboard,
+      'getLeaderboard'
+    );
+  }
+
+  public async getUserRank(args: { input: UserRankQueryDto }): Promise<ITypedBackendResponse<UserRank>> {
+    return this.execute<UserRank>(
+      () => this.sdk.GetUserRank({ input: args.input }),
+      'getUserRank',
+      (r) => !!r?.getUserRank,
+      'getUserRank'
+    );
+  }
+
+  public async rebuildLeaderboardCache(): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.RebuildLeaderboardCache(),
+      'rebuildLeaderboardCache',
+      (r) => r?.rebuildLeaderboardCache !== undefined,
+      'rebuildLeaderboardCache'
+    );
+  }
+
+  // ============= DASHBOARD / ANALYTICS METHODS =============
+
+  public async getAthleteDashboard(athleteId: string): Promise<ITypedBackendResponse<DashboardSummary>> {
+    return this.execute<DashboardSummary>(
+      () => this.sdk.GetAthleteDashboard({ athleteId }),
+      'athleteDashboard',
+      (r) => !!r?.athleteDashboard,
+      'getAthleteDashboard'
+    );
+  }
+
+  public async getAthleteScoreHistory(args: { input: ScoreHistoryQueryDto }): Promise<ITypedBackendResponse<ScoreHistoryEntry[]>> {
+    return this.execute<ScoreHistoryEntry[]>(
+      () => this.sdk.GetAthleteScoreHistory({ input: args.input }),
+      'athleteScoreHistory',
+      (r) => Array.isArray(r?.athleteScoreHistory),
+      'getAthleteScoreHistory'
+    );
+  }
+
+  public async getAthleteRankHistory(args: { input: RankHistoryQueryDto }): Promise<ITypedBackendResponse<RankHistoryEntry[]>> {
+    return this.execute<RankHistoryEntry[]>(
+      () => this.sdk.GetAthleteRankHistory({ input: args.input }),
+      'athleteRankHistory',
+      (r) => Array.isArray(r?.athleteRankHistory),
+      'getAthleteRankHistory'
+    );
+  }
+
+  public async getAthleteRankContext(args: { input: RankContextQueryDto }): Promise<ITypedBackendResponse<RankContext>> {
+    return this.execute<RankContext>(
+      () => this.sdk.GetAthleteRankContext({ input: args.input }),
+      'athleteRankContext',
+      (r) => !!r?.athleteRankContext,
+      'getAthleteRankContext'
+    );
+  }
+
+  public async getAthleteActivities(args: { input: ActivitiesQueryDto }): Promise<ITypedBackendResponse<ActivitiesResponse>> {
+    return this.execute<ActivitiesResponse>(
+      () => this.sdk.GetAthleteActivities({ input: args.input }),
+      'athleteActivities',
+      (r) => !!r?.athleteActivities,
+      'getAthleteActivities'
+    );
+  }
+
+  public async getAthleteActivityDetail(args: { input: ActivityDetailQueryDto }): Promise<ITypedBackendResponse<ActivityDetail>> {
+    return this.execute<ActivityDetail>(
+      () => this.sdk.GetAthleteActivityDetail({ input: args.input }),
+      'athleteActivityDetail',
+      (r) => !!r?.athleteActivityDetail,
+      'getAthleteActivityDetail'
+    );
+  }
+
+  public async getAthleteComponentSummary(args: { input: ComponentSummaryQueryDto }): Promise<ITypedBackendResponse<ComponentSummary>> {
+    return this.execute<ComponentSummary>(
+      () => this.sdk.GetAthleteComponentSummary({ input: args.input }),
+      'athleteComponentSummary',
+      (r) => !!r?.athleteComponentSummary,
+      'getAthleteComponentSummary'
+    );
+  }
+
+  // ============= SOCIAL METHODS =============
+
+  public async getSocialAggregates(args: {
+    input: { athleteId: string; platform: Platform; startDate: string; endDate: string; periodType?: PeriodType; };
+  }): Promise<ITypedBackendResponse<any[]>> {
+    return this.execute<any[]>(
+      () => this.sdk.GetSocialAggregates({
+        athleteId: args.input.athleteId,
+        platform: args.input.platform as any,
+        range: { start: args.input.startDate, end: args.input.endDate },
+        periodType: args.input.periodType as any,
+      }),
+      'socialAggregates',
+      (r) => r?.socialAggregates !== undefined,
+      'getSocialAggregates'
+    );
+  }
+
+  public async getPostsWithComparison(args: {
+    input: { athleteId: string; platform: Platform; sortBy?: PostSortOption; contentType?: ContentType; limit?: number; offset?: number; comparisonWindowDays?: number; };
+  }): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetPostsWithComparison({
+        athleteId: args.input.athleteId,
+        platform: args.input.platform as any,
+        options: {
+          sortBy: args.input.sortBy as any,
+          contentType: args.input.contentType as any,
+          limit: args.input.limit,
+          offset: args.input.offset,
+          comparisonWindowDays: args.input.comparisonWindowDays,
+        },
+      }),
+      'postsWithComparison',
+      (r) => r?.postsWithComparison !== undefined,
+      'getPostsWithComparison'
+    );
+  }
+
+  public async getAthleteActivityDates(athleteId: string): Promise<ITypedBackendResponse<ActivityDatesResponse>> {
+    return this.execute<ActivityDatesResponse>(
+      () => this.sdk.GetAthleteActivityDates({ input: { athleteId } as any }),
+      'athleteActivityDates',
+      (r) => r?.athleteActivityDates?.dates !== undefined,
+      'getAthleteActivityDates'
+    );
+  }
+
+  // ============= NOTIFICATION METHODS =============
+
+  public async getMyNotifications(options?: {
+    limit?: number; offset?: number; includeRead?: boolean; includeDismissed?: boolean; types?: string[];
+  }): Promise<ITypedBackendResponse<NotificationListResponse>> {
+    return this.execute<NotificationListResponse>(
+      () => this.sdk.MyNotifications({ input: (options || {}) as any }),
+      'myNotifications',
+      (r) => r?.myNotifications?.notifications !== undefined,
+      'getMyNotifications'
+    );
+  }
+
+  public async getNotificationUnreadCount(): Promise<ITypedBackendResponse<UnreadCountResponse>> {
+    return this.execute<UnreadCountResponse>(
+      () => this.sdk.NotificationUnreadCount(),
+      'notificationUnreadCount',
+      (r) => r?.notificationUnreadCount?.count !== undefined,
+      'getNotificationUnreadCount'
+    );
+  }
+
+  public async getMyNotificationPreferences(): Promise<ITypedBackendResponse<NotificationPreference>> {
+    return this.execute<NotificationPreference>(
+      () => this.sdk.MyNotificationPreferences(),
+      'myNotificationPreferences',
+      (r) => r?.myNotificationPreferences?.id !== undefined,
+      'getMyNotificationPreferences'
+    );
+  }
+
+  public async markNotificationAsRead(notificationId: string): Promise<ITypedBackendResponse<Notification>> {
+    return this.execute<Notification>(
+      () => this.sdk.MarkNotificationAsRead({ input: { notificationId } as any }),
+      'markNotificationAsRead',
+      (r) => r?.markNotificationAsRead?.id !== undefined,
+      'markNotificationAsRead'
+    );
+  }
+
+  public async markAllNotificationsAsRead(): Promise<ITypedBackendResponse<number>> {
+    return this.execute<number>(
+      () => this.sdk.MarkAllNotificationsAsRead(),
+      'markAllNotificationsAsRead',
+      (r) => r?.markAllNotificationsAsRead !== undefined,
+      'markAllNotificationsAsRead'
+    );
+  }
+
+  public async dismissNotification(notificationId: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.DismissNotification({ input: { notificationId } as any }),
+      'dismissNotification',
+      (r) => r?.dismissNotification !== undefined,
+      'dismissNotification'
+    );
+  }
+
+  public async registerDeviceToken(token: string, platform: string, deviceName?: string): Promise<ITypedBackendResponse<DeviceTokenType>> {
+    const input: RegisterDeviceTokenDto = { token, platform, deviceName };
+    return this.execute<DeviceTokenType>(
+      () => this.sdk.RegisterDeviceToken({ input }),
+      'registerDeviceToken',
+      (r) => r?.registerDeviceToken?.id !== undefined,
+      'registerDeviceToken'
+    );
+  }
+
+  public async unregisterDeviceToken(token: string): Promise<ITypedBackendResponse<boolean>> {
+    const input: UnregisterDeviceTokenDto = { token };
+    return this.execute<boolean>(
+      () => this.sdk.UnregisterDeviceToken({ input }),
+      'unregisterDeviceToken',
+      (r) => r?.unregisterDeviceToken !== undefined,
+      'unregisterDeviceToken'
+    );
+  }
+
+  public async updateNotificationPreferences(input: {
+    emailEnabled?: boolean; inAppEnabled?: boolean; pushEnabled?: boolean; mutedTypes?: string[];
+  }): Promise<ITypedBackendResponse<NotificationPreference>> {
+    return this.execute<NotificationPreference>(
+      () => this.sdk.UpdateNotificationPreferences({ input: input as any }),
+      'updateNotificationPreferences',
+      (r) => r?.updateNotificationPreferences?.id !== undefined,
+      'updateNotificationPreferences'
+    );
+  }
+
+  // ============= FOLLOW METHODS =============
+
+  public async followAthlete(athleteId: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.FollowAthlete({ input: { athleteId } }),
+      'followAthlete',
+      (r) => r?.followAthlete !== undefined,
+      'followAthlete'
+    );
+  }
+
+  public async unfollowAthlete(athleteId: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.UnfollowAthlete({ input: { athleteId } }),
+      'unfollowAthlete',
+      (r) => r?.unfollowAthlete !== undefined,
+      'unfollowAthlete'
+    );
+  }
+
+  public async isFollowingAthlete(athleteId: string): Promise<ITypedBackendResponse<IsFollowingResponse>> {
+    return this.execute<IsFollowingResponse>(
+      () => this.sdk.IsFollowingAthlete({ input: { athleteId } }),
+      'isFollowingAthlete',
+      (r) => r?.isFollowingAthlete?.isFollowing !== undefined,
+      'isFollowingAthlete'
+    );
+  }
+
+  public async getMyFollowedAthletes(options?: { limit?: number; offset?: number; }): Promise<ITypedBackendResponse<FollowedAthletesListResponse>> {
+    return this.execute<FollowedAthletesListResponse>(
+      () => this.sdk.MyFollowedAthletes({ input: (options || null) as any }),
+      'myFollowedAthletes',
+      (r) => r?.myFollowedAthletes?.athletes !== undefined,
+      'getMyFollowedAthletes'
+    );
+  }
+
+  // ============= ONBOARDING METHODS =============
+
+  public async deleteOnboardingAthlete(): Promise<ITypedBackendResponse<{ success: boolean; athleteId?: string; error?: string }>> {
+    return this.execute<{ success: boolean; athleteId?: string; error?: string }>(
+      () => this.sdk.DeleteOnboardingAthlete(),
+      'deleteOnboardingAthlete',
+      (r) => r?.deleteOnboardingAthlete?.success === true,
+      'deleteOnboardingAthlete'
+    );
+  }
+
+  public async updateOnboardingProgress(
+    step: number,
+    complete?: boolean
+  ): Promise<ITypedBackendResponse<{ success: boolean; step?: number; complete?: boolean; error?: string }>> {
+    return this.execute<{ success: boolean; step?: number; complete?: boolean; error?: string }>(
+      () => this.sdk.UpdateOnboardingProgress({ input: { step, complete } as any }),
+      'updateOnboardingProgress',
+      (r) => r?.updateOnboardingProgress?.success === true,
+      'updateOnboardingProgress'
+    );
+  }
+
+  public async getOnboardingProgress(): Promise<ITypedBackendResponse<{ success: boolean; step?: number; complete?: boolean; athleteId?: string; error?: string }>> {
+    return this.execute<{ success: boolean; step?: number; complete?: boolean; athleteId?: string; error?: string }>(
+      () => this.sdk.GetOnboardingProgress(),
+      'getOnboardingProgress',
+      (r) => r?.getOnboardingProgress?.success === true,
+      'getOnboardingProgress'
+    );
+  }
+
+  public async getPublicAthleteIntegrationStatus(athleteId: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetPublicAthleteIntegrationStatus({ athleteId }),
+      'getPublicAthleteIntegrationStatus',
+      (r) => r?.getPublicAthleteIntegrationStatus != null,
+      'getPublicAthleteIntegrationStatus'
+    );
+  }
+
+  // ============= EMAIL CAMPAIGN METHODS =============
+
+  public async getEmailCampaigns(args: {
+    status: string; search?: string; page?: number; limit?: number;
+  }): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetEmailCampaigns({ ...args }),
+      'getEmailCampaigns',
+      (r) => r?.getEmailCampaigns?.campaigns != null,
+      'getEmailCampaigns'
+    );
+  }
+
+  public async createEmailCampaign(input: any): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.CreateEmailCampaign({ input }),
+      'createEmailCampaign',
+      (r) => !!r?.createEmailCampaign?._id,
+      'createEmailCampaign'
+    );
+  }
+
+  public async updateEmailCampaign(id: string, input: any): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.UpdateEmailCampaign({ id, input }),
+      'updateEmailCampaign',
+      (r) => !!r?.updateEmailCampaign?._id,
+      'updateEmailCampaign'
+    );
+  }
+
+  public async deleteEmailCampaign(id: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.DeleteEmailCampaign({ id }),
+      'deleteEmailCampaign',
+      (r) => r?.deleteEmailCampaign === true,
+      'deleteEmailCampaign'
+    );
+  }
+
+  public async cloneEmailCampaign(id: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.CloneEmailCampaign({ id }),
+      'cloneEmailCampaign',
+      (r) => !!r?.cloneEmailCampaign?._id,
+      'cloneEmailCampaign'
+    );
+  }
+
+  public async sendTestEmail(campaignId: string, email: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.SendTestEmail({ campaignId, adminEmail: email }),
+      'sendTestEmail',
+      (r) => !!r?.sendTestEmail,
+      'sendTestEmail'
+    );
+  }
+
+  public async sendBulkEmail(campaignId: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.SendBulkEmail({ campaignId }),
+      'sendBulkEmail',
+      (r) => !!r?.sendBulkEmail,
+      'sendBulkEmail'
+    );
+  }
+
+  public async scheduleEmailCampaign(campaignId: string, scheduledFor: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.ScheduleEmailCampaign({ campaignId, scheduledFor }),
+      'scheduleEmailCampaign',
+      (r) => !!r?.scheduleEmailCampaign?._id,
+      'scheduleEmailCampaign'
+    );
+  }
+
+  public async cancelScheduledEmail(campaignId: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.CancelScheduledEmail({ campaignId }),
+      'cancelScheduledEmail',
+      (r) => !!r?.cancelScheduledEmail?._id,
+      'cancelScheduledEmail'
+    );
+  }
+
+  public async getAudiencePreview(filters: any): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetAudiencePreview({ filters }),
+      'getAudiencePreview',
+      (r) => r?.getAudiencePreview?.total != null,
+      'getAudiencePreview'
+    );
+  }
+
+  public async getSendGridTemplates(): Promise<ITypedBackendResponse<any[]>> {
+    return this.execute<any[]>(
+      () => this.sdk.GetSendGridTemplates(),
+      'getSendGridTemplates',
+      (r) => r?.getSendGridTemplates != null,
+      'getSendGridTemplates'
+    );
+  }
+
+  public async getSendGridTemplatePreview(templateId: string): Promise<ITypedBackendResponse<string>> {
+    return this.execute<string>(
+      () => this.sdk.GetSendGridTemplatePreview({ templateId }),
+      'getSendGridTemplatePreview',
+      (r) => r?.getSendGridTemplatePreview != null,
+      'getSendGridTemplatePreview'
+    );
+  }
+
+  public async getEmailSegments(): Promise<ITypedBackendResponse<any[]>> {
+    return this.execute<any[]>(
+      () => this.sdk.GetEmailSegments(),
+      'getEmailSegments',
+      (r) => r?.getEmailSegments != null,
+      'getEmailSegments'
+    );
+  }
+
+  public async createEmailSegment(input: any): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.CreateEmailSegment({ input }),
+      'createEmailSegment',
+      (r) => !!r?.createEmailSegment?._id,
+      'createEmailSegment'
+    );
+  }
+
+  public async updateEmailSegment(id: string, input: any): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.UpdateEmailSegment({ id, input }),
+      'updateEmailSegment',
+      (r) => !!r?.updateEmailSegment?._id,
+      'updateEmailSegment'
+    );
+  }
+
+  public async deleteEmailSegment(id: string): Promise<ITypedBackendResponse<boolean>> {
+    return this.execute<boolean>(
+      () => this.sdk.DeleteEmailSegment({ id }),
+      'deleteEmailSegment',
+      (r) => r?.deleteEmailSegment === true,
+      'deleteEmailSegment'
+    );
+  }
+
+  // ============= AI COACH METHODS =============
+
+  public async getAiCoachThread(): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetAiCoachThread(),
+      'getAiCoachThread',
+      (r) => r?.getAiCoachThread !== undefined,
+      'getAiCoachThread'
+    );
+  }
+
+  public async getAiCoachThreadHistory(limit?: number): Promise<ITypedBackendResponse<any[]>> {
+    return this.execute<any[]>(
+      () => this.sdk.GetAiCoachThreadHistory({ limit: limit ?? 10 }),
+      'getAiCoachThreadHistory',
+      (r) => Array.isArray(r?.getAiCoachThreadHistory),
+      'getAiCoachThreadHistory'
+    );
+  }
+
+  public async getAiCoachThreadMessages(threadId: string): Promise<ITypedBackendResponse<any[]>> {
+    return this.execute<any[]>(
+      () => this.sdk.GetAiCoachThreadMessages({ threadId }),
+      'getAiCoachThreadMessages',
+      (r) => Array.isArray(r?.getAiCoachThreadMessages),
+      'getAiCoachThreadMessages'
+    );
+  }
+
+  public async getAiCoachConfig(): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetAiCoachConfig(),
+      'getAiCoachConfig',
+      (r) => r?.getAiCoachConfig?.athleteId !== undefined,
+      'getAiCoachConfig'
+    );
+  }
+
+  public async sendAiCoachMessage(input: { threadId: string; message: string }): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.SendAiCoachMessage({ input: input as any }),
+      'sendAiCoachMessage',
+      (r) => !!r?.sendAiCoachMessage?._id,
+      'sendAiCoachMessage'
+    );
+  }
+
+  public async updateAiCoachConfig(input: { enabled?: boolean; nudgesEnabled?: boolean; preferredFocus?: string }): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.UpdateAiCoachConfig({ input: input as any }),
+      'updateAiCoachConfig',
+      (r) => r?.updateAiCoachConfig?.athleteId !== undefined,
+      'updateAiCoachConfig'
+    );
+  }
+
+  // ============= AI COACH NUDGE METHODS =============
+
+  public async getAiCoachNudges(input?: { unreadOnly?: boolean }): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetAiCoachNudges({ input: input as any }),
+      'getAiCoachNudges',
+      (r) => r?.getAiCoachNudges !== undefined,
+      'getAiCoachNudges'
+    );
+  }
+
+  public async getAiCoachUnreadNudgeCount(): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.GetAiCoachUnreadNudgeCount(),
+      'getAiCoachUnreadNudgeCount',
+      (r) => r?.getAiCoachUnreadNudgeCount !== undefined,
+      'getAiCoachUnreadNudgeCount'
+    );
+  }
+
+  public async markAiCoachNudgeRead(nudgeId: string): Promise<ITypedBackendResponse<any>> {
+    return this.execute<any>(
+      () => this.sdk.MarkAiCoachNudgeRead({ nudgeId }),
+      'markAiCoachNudgeRead',
+      (r) => r?.markAiCoachNudgeRead !== undefined,
+      'markAiCoachNudgeRead'
+    );
+  }
+}
+
+// Re-export UserImages type for consumers
+import { UserImages } from '../client';