@globalscoutme/api-client 1.1.9 → 1.1.11

package/README.md

@@ -0,0 +1,297 @@
+# @globalscoutme/api-client
+
+Auto-generated TypeScript HTTP client for the GlobalScoutMe API, built with [`@hey-api/openapi-ts`](https://heyapi.dev/) and axios.
+
+## Install
+
+```bash
+npm install @globalscoutme/api-client
+```
+
+## Setup
+
+Configure the client once at app startup with your API base URL and auth token:
+
+```ts
+import { client } from '@globalscoutme/api-client';
+
+client.setConfig({
+  baseURL: 'https://your-api-url.com',
+  headers: {
+    Authorization: `Bearer ${yourSupabaseAccessToken}`,
+  },
+});
+```
+
+## Usage
+
+All endpoints are grouped by controller and fully typed:
+
+```ts
+import {
+  Auth,
+  Dashboard,
+  Players,
+  Profile,
+  Documents,
+  Videos,
+  Achievements,
+  Body,
+  Index,
+  Kyc,
+  Offers,
+  Organizations,
+  Clubs,
+  Challenges,
+  Training,
+  Invitations,
+  Storage,
+  Subscriptions,
+} from '@globalscoutme/api-client';
+
+// Auth
+const authMe = await Auth.getAuthMe();
+// Returns { id: string, userType: string | null }
+
+// Players
+const player = await Players.getMe();
+await Players.patchMe({ body: { fullName: 'John Doe' } });
+await Players.deleteMe();
+const dashboard = await Players.getMyDashboard();
+await Players.heartbeat({ body: { timezone: 'Europe/Bucharest' } });
+const results = await Players.searchPlayers({
+  body: {
+    search: 'John',
+    page: 1,
+    pageSize: 20,
+    sortBy: 'age_asc',
+    nationalities: ['EG', 'MA'],
+    positions: ['CM', 'CB'],
+    baseFoot: 'right',
+    isFreeAgent: true,
+    hasVideo: true,
+    heightOperator: 'gte',
+    heightCm: 180,
+  },
+});
+const playerProfile = await Players.getPlayerById({
+  path: { id: 'player-uuid' },
+});
+const playerMeasurements = await Players.getPlayerMeasurementProfile({
+  path: { id: 'player-uuid' },
+});
+// Returns { status, body, cmj, session, updatedAt } — accessible to all roles (no player-only restriction)
+// status: 'missing' | 'partial' | 'ready' | 'needs_update'
+const playerVideoMetrics = await Players.getPlayerVideoMetrics({
+  path: { id: 'player-uuid' },
+});
+// Returns { id, createdAt, videoDurationS, physicalMetrics, trackingQuality, trackedFrames, totalFrames }
+// physicalMetrics: { totalDistance, sprintDistance, maxSpeed, averageSpeed, highIntensityRuns, sprints }
+// Speed/distance values are strings with units already included (e.g. "31.0 km/h", "21.4 m")
+// trackingQuality: confidence label from the analysis service (e.g. "High Confidence") — null if unavailable
+// Returns 404 if the player has no completed video analysis yet
+const playerReport = await Players.getPlayerReport({
+  path: { id: 'player-uuid' },
+});
+// Returns { reportReferenceId, generatedAt, scouterView: { technicalPillar, physicalPillar, tacticalPillar, mentalPillar } }
+// Returns 404 if the player has no completed AI report yet
+
+// Profile
+const profile = await Profile.getProfileMe();
+await Profile.updateProfileMe({ body: { dominantFoot: 'Right' } });
+
+// Documents
+const docs = await Documents.getMyDocuments();
+await Documents.createDocument({ body: { type: 'license' } });
+
+// Videos
+const videos = await Videos.getMyVideos();
+await Videos.createVideo({
+  body: { type: 'cmj', storagePath: 'path/to/video' },
+});
+const playUrl = await Videos.getVideoPlayUrl({ path: { id: 'video-uuid' } });
+await Videos.deleteVideo({ path: { id: 'video-uuid' } });
+
+// Achievements
+const catalog = await Achievements.getAchievementsCatalog();
+const myAchievements = await Achievements.getMyAchievements();
+
+// Body measurements
+const measurement = await Body.getMyMeasurements();
+await Body.createMeasurement({ body: { heightCm: 180 } });
+
+// Index (lookup tables)
+const positions = await Index.getIndexItems({
+  path: { tableName: 'positions' },
+});
+const countries = await Index.getCountries();
+// Returns [{ code: 'BR', name: 'Brazil', nationalityName: 'Brazilian', flagEmoji: '🇧🇷' }, ...]
+
+// Dashboard (scout/club portal — single aggregated call)
+const dashboard = await Dashboard.getScoutDashboard();
+// Returns: stats (watchlisted, offersSent, playersViewed, videosWatched),
+//          lastPlayersViewed (last 6 distinct players),
+//          lastVideosWatched (last 6 distinct videos with player info)
+
+const videoUrl = await Dashboard.getScoutVideoPlayUrl({
+  path: { id: 'video-uuid' },
+});
+// Returns signed play URL + records the view in video_views
+
+// Offers (conversations between scouts and players)
+const conversations = await Offers.listConversations({
+  query: { filter: 'all', page: 1, pageSize: 20 },
+});
+const conversation = await Offers.createConversation({
+  body: { playerId: 'player-uuid', initialMessage: 'Hi!' },
+});
+const messages = await Offers.listMessages({
+  path: { id: 'conversation-uuid' },
+  query: { page: 1, pageSize: 20 },
+});
+await Offers.sendMessage({
+  path: { id: 'conversation-uuid' },
+  body: { body: 'Looking forward to it!' },
+});
+await Offers.markConversationRead({ path: { id: 'conversation-uuid' } });
+
+// Organizations
+const org = await Organizations.getMyOrganization();
+await Organizations.updateMyOrganization({ body: { name: 'FC Example' } });
+await Organizations.registerClub({
+  body: { name: 'FC Example', email: 'admin@example.com' },
+});
+
+// Clubs (coach/admin club entries within an organization)
+const clubs = await Clubs.getMyClubs();
+const club = await Clubs.createMyClub({ body: { name: 'U19 Team' } });
+await Clubs.updateMyClub({
+  path: { id: 'club-uuid' },
+  body: { name: 'U21 Team' },
+});
+await Clubs.deleteMyClub({ path: { id: 'club-uuid' } });
+
+// Challenges
+const challengeCatalog = await Challenges.getChallengesCatalog();
+const myChallenges = await Challenges.getMyChallenges();
+
+// Training
+const grouped = await Training.getTrainingGrouped();
+const trainingList = await Training.getTrainingList({
+  query: { categoryCode: 'fitness', page: 1, pageSize: 20 },
+});
+const trainingItem = await Training.getTrainingById({
+  path: { id: 'training-uuid' },
+});
+
+// Invitations (org admin invites members)
+await Invitations.sendInvitation({
+  body: { email: 'coach@example.com', role: 'coach' },
+});
+const invitations = await Invitations.listInvitations();
+await Invitations.resendInvitation({ path: { id: 'invitation-uuid' } });
+await Invitations.deleteInvitation({ path: { id: 'invitation-uuid' } });
+await Invitations.acceptInvitation(); // called after Supabase auth callback
+
+// KYC — SmileID Enhanced Document Verification
+//
+// Two integration options:
+
+// Option A — Smile Links (recommended for web)
+// Backend returns a hosted SmileID URL; redirect the user to it.
+// SmileID handles the full capture UI and fires the webhook when done.
+const linkResult = await Kyc.startSmileLink({
+  body: {
+    country: 'gh', // stored on the verification record; does NOT filter the SmileID dropdown
+    channel: 'web',
+    returnUrl: 'https://yourapp.com/onboarding/kyc/callback',
+  },
+});
+// linkResult: { url, jobId, status, retriesRemaining }
+// url is null when no redirect is needed (approved / blocked / processing).
+if (linkResult.data.url) {
+  window.location.href = linkResult.data.url; // redirect user to SmileID
+}
+// The SmileID hosted page shows all countries configured in index.kyc_supported_id_types.
+// The user selects their country and document type on that page.
+// After the user returns to returnUrl, poll getKycStatus to confirm the result.
+// markSubmittedKyc is NOT needed for Smile Links — SmileID fires the webhook directly.
+
+// Option B — SDK widget (embedded, for mobile / advanced web)
+const kycResult = await Kyc.startKyc({
+  body: { country: 'gh', channel: 'web' },
+});
+// kycResult: { token, partnerId, jobId, status, retriesRemaining }
+// Pass token + partnerId to the SmileID web SDK widget to start document capture.
+// After the SDK reports successful submission, call markSubmittedKyc with jobId.
+await Kyc.markSubmittedKyc({ body: { jobId: kycResult.data.jobId! } });
+// SmileID also calls POST /kyc/webhook under the configured API base/prefix
+// (for staging: https://staging.globalscoutme.com/api/kyc/webhook).
+
+const kycStatus = await Kyc.getKycStatus({
+  path: { userId: supabaseAuthUuid },
+});
+// kycStatus: { status, retryCount, retriesRemaining }
+// status: 'pending' | 'capture_started' | 'processing' | 'approved' | 'rejected' | 'blocked'
+// Older API clients may still see legacy 'in_progress', which maps to 'capture_started'.
+
+// Subscriptions (Stripe recurring billing)
+const plans = await Subscriptions.getSubscriptionPlans();
+// Returns: { plans: [{ id, code, name, price, currency, billingInterval, trialDays, features, displayOrder }] }
+
+const mySubscription = await Subscriptions.getMySubscription();
+// Returns: { status, isActive, planId, planName, billingInterval,
+//            currentPeriodStart, currentPeriodEnd, cancelAtPeriodEnd, canceledAt, gracePeriodUntil }
+// status: 'inactive' when the user has never subscribed
+
+// Start a subscription — redirect the user to the returned URL
+const checkout = await Subscriptions.createCheckout({
+  body: {
+    providerProductId: 'billing-provider-products-uuid', // pick from billing_provider_products table
+    successUrl: 'https://yourapp.com/subscription/success', // or a mobile deep-link
+    cancelUrl: 'https://yourapp.com/subscription/cancel',
+  },
+});
+// redirect user to checkout.url
+
+// Open the Stripe Billing Portal (manage / cancel subscription)
+const portal = await Subscriptions.createPortal({
+  body: { returnUrl: 'https://yourapp.com/account' },
+});
+// redirect user to portal.url
+
+// Storage — get a signed upload URL, then PUT the file directly to Supabase Storage
+const { uploadUrl, token, path, bucket, expiresIn } = await Storage.createUploadUrl({
+  body: { bucket: 'avatars', contentType: 'image/jpeg', sizeBytes: 204800 },
+});
+await fetch(uploadUrl, {
+  method: 'PUT',
+  body: fileBlob,
+  headers: { 'Content-Type': 'image/jpeg' },
+});
+// persist `path` on the player record (e.g. patchMe with avatarPath: path)
+```
+
+## Updating auth token
+
+Update the Bearer token after sign-in or token refresh:
+
+```ts
+client.setConfig({
+  headers: {
+    Authorization: `Bearer ${newAccessToken}`,
+  },
+});
+```
+
+## Versioning
+
+This package is auto-generated from the backend OpenAPI spec. Version increments follow semver:
+
+- **patch** — no API shape changes
+- **minor** — new endpoints added
+- **major** — breaking changes (renamed/removed endpoints or fields)
+
+## Package format
+
+The published package ships compiled JavaScript (`dist/`) alongside the raw TypeScript source. `main` points to `dist/index.js` so all bundlers work without extra configuration.

package/client/client.gen.ts

@@ -3,12 +3,7 @@
 import { createSseClient } from '../core/serverSentEvents.gen.js';
 import type { HttpMethod } from '../core/types.gen.js';
 import { getValidRequestBody } from '../core/utils.gen.js';
-import type {
-  Client,
-  Config,
-  RequestOptions,
-  ResolvedRequestOptions,
-} from './types.gen.js';
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from './types.gen.js';
 import {
   buildUrl,
   createConfig,
@@ -34,12 +29,7 @@ export const createClient = (config: Config = {}): Client => {
     return getConfig();
   };
 
-  const interceptors = createInterceptors<
-    Request,
-    Response,
-    unknown,
-    ResolvedRequestOptions
-  >();
+  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>();
 
   const beforeRequest = async (options: RequestOptions) => {
     const opts = {
@@ -105,12 +95,7 @@ export const createClient = (config: Config = {}): Client => {
 
       for (const fn of interceptors.error.fns) {
         if (fn) {
-          finalError = (await fn(
-            error,
-            undefined as any,
-            request,
-            opts,
-          )) as unknown;
+          finalError = (await fn(error, undefined as any, request, opts)) as unknown;
         }
       }
 
@@ -147,10 +132,7 @@ export const createClient = (config: Config = {}): Client => {
           ? getParseAs(response.headers.get('Content-Type'))
           : opts.parseAs) ?? 'json';
 
-      if (
-        response.status === 204 ||
-        response.headers.get('Content-Length') === '0'
-      ) {
+      if (response.status === 204 || response.headers.get('Content-Length') === '0') {
         let emptyData: any;
         switch (parseAs) {
           case 'arrayBuffer':
@@ -252,34 +234,29 @@ export const createClient = (config: Config = {}): Client => {
         };
   };
 
-  const makeMethodFn =
-    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
-      request({ ...options, method });
+  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+    request({ ...options, method });
 
-  const makeSseFn =
-    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
-      const { opts, url } = await beforeRequest(options);
-      return createSseClient({
-        ...opts,
-        body: opts.body as BodyInit | null | undefined,
-        headers: opts.headers as unknown as Record<string, string>,
-        method,
-        onRequest: async (url, init) => {
-          let request = new Request(url, init);
-          for (const fn of interceptors.request.fns) {
-            if (fn) {
-              request = await fn(request, opts);
-            }
+  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body as BodyInit | null | undefined,
+      headers: opts.headers as unknown as Record<string, string>,
+      method,
+      onRequest: async (url, init) => {
+        let request = new Request(url, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request = await fn(request, opts);
           }
-          return request;
-        },
-        serializedBody: getValidRequestBody(opts) as
-          | BodyInit
-          | null
-          | undefined,
-        url,
-      });
-    };
+        }
+        return request;
+      },
+      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
+      url,
+    });
+  };
 
   return {
     buildUrl,

package/client/types.gen.ts

@@ -5,10 +5,7 @@ import type {
   ServerSentEventsOptions,
   ServerSentEventsResult,
 } from '../core/serverSentEvents.gen.js';
-import type {
-  Client as CoreClient,
-  Config as CoreConfig,
-} from '../core/types.gen.js';
+import type { Client as CoreClient, Config as CoreConfig } from '../core/types.gen.js';
 import type { Middleware } from './utils.gen.js';
 
 export type ResponseStyle = 'data' | 'fields';
@@ -41,14 +38,7 @@ export interface Config<T extends ClientOptions = ClientOptions>
    *
    * @default 'auto'
    */
-  parseAs?:
-    | 'arrayBuffer'
-    | 'auto'
-    | 'blob'
-    | 'formData'
-    | 'json'
-    | 'stream'
-    | 'text';
+  parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
   /**
    * Should we return only data or multiple fields (data, error, response, etc.)?
    *
@@ -117,32 +107,22 @@ export type RequestResult<
           ? TData[keyof TData]
           : TData
         : {
-            data: TData extends Record<string, unknown>
-              ? TData[keyof TData]
-              : TData;
+            data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
             request: Request;
             response: Response;
           }
     >
   : Promise<
       TResponseStyle extends 'data'
-        ?
-            | (TData extends Record<string, unknown>
-                ? TData[keyof TData]
-                : TData)
-            | undefined
+        ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined
         : (
             | {
-                data: TData extends Record<string, unknown>
-                  ? TData[keyof TData]
-                  : TData;
+                data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
                 error: undefined;
               }
             | {
                 data: undefined;
-                error: TError extends Record<string, unknown>
-                  ? TError[keyof TError]
-                  : TError;
+                error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
               }
           ) & {
             request: Request;
@@ -162,7 +142,7 @@ type MethodFn = <
   ThrowOnError extends boolean = false,
   TResponseStyle extends ResponseStyle = 'fields',
 >(
-  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>,
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>
 ) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 
 type SseFn = <
@@ -171,7 +151,7 @@ type SseFn = <
   ThrowOnError extends boolean = false,
   TResponseStyle extends ResponseStyle = 'fields',
 >(
-  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>,
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>
 ) => Promise<ServerSentEventsResult<TData, TError>>;
 
 type RequestFn = <
@@ -181,10 +161,7 @@ type RequestFn = <
   TResponseStyle extends ResponseStyle = 'fields',
 >(
   options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> &
-    Pick<
-      Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>,
-      'method'
-    >,
+    Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>
 ) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 
 type BuildUrlFn = <
@@ -195,16 +172,10 @@ type BuildUrlFn = <
     url: string;
   },
 >(
-  options: TData & Options<TData>,
+  options: TData & Options<TData>
 ) => string;
 
-export type Client = CoreClient<
-  RequestFn,
-  Config,
-  MethodFn,
-  BuildUrlFn,
-  SseFn
-> & {
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
   interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
 };
 
@@ -217,7 +188,7 @@ export type Client = CoreClient<
  * to ensure your client always has the correct values.
  */
 export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
-  override?: Config<ClientOptions & T>,
+  override?: Config<ClientOptions & T>
 ) => Config<Required<ClientOptions> & T>;
 
 export interface TDataShape {

package/client/utils.gen.ts

@@ -9,12 +9,7 @@ import {
   serializePrimitiveParam,
 } from '../core/pathSerializer.gen.js';
 import { getUrl } from '../core/utils.gen.js';
-import type {
-  Client,
-  ClientOptions,
-  Config,
-  RequestOptions,
-} from './types.gen.js';
+import type { Client, ClientOptions, Config, RequestOptions } from './types.gen.js';
 
 export const createQuerySerializer = <T = unknown>({
   parameters = {},
@@ -70,9 +65,7 @@ export const createQuerySerializer = <T = unknown>({
 /**
  * Infers parseAs value from provided Content-Type header.
  */
-export const getParseAs = (
-  contentType: string | null,
-): Exclude<Config['parseAs'], 'auto'> => {
+export const getParseAs = (contentType: string | null): Exclude<Config['parseAs'], 'auto'> => {
   if (!contentType) {
     // If no Content-Type header is provided, the best we can do is return the raw response body,
     // which is effectively the same as the 'stream' option.
@@ -85,10 +78,7 @@ export const getParseAs = (
     return;
   }
 
-  if (
-    cleanContent.startsWith('application/json') ||
-    cleanContent.endsWith('+json')
-  ) {
+  if (cleanContent.startsWith('application/json') || cleanContent.endsWith('+json')) {
     return 'json';
   }
 
@@ -97,9 +87,7 @@ export const getParseAs = (
   }
 
   if (
-    ['application/', 'audio/', 'image/', 'video/'].some((type) =>
-      cleanContent.startsWith(type),
-    )
+    ['application/', 'audio/', 'image/', 'video/'].some((type) => cleanContent.startsWith(type))
   ) {
     return 'blob';
   }
@@ -115,7 +103,7 @@ const checkForExistence = (
   options: Pick<RequestOptions, 'auth' | 'query'> & {
     headers: Headers;
   },
-  name?: string,
+  name?: string
 ): boolean => {
   if (!name) {
     return false;
@@ -206,10 +194,7 @@ export const mergeHeaders = (
       continue;
     }
 
-    const iterator =
-      header instanceof Headers
-        ? headersEntries(header)
-        : Object.entries(header);
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
 
     for (const [key, value] of iterator) {
       if (value === null) {
@@ -223,7 +208,7 @@ export const mergeHeaders = (
         // content value in OpenAPI specification is 'application/json'
         mergedHeaders.set(
           key,
-          typeof value === 'object' ? JSON.stringify(value) : (value as string),
+          typeof value === 'object' ? JSON.stringify(value) : (value as string)
         );
       }
     }
@@ -235,18 +220,15 @@ type ErrInterceptor<Err, Res, Req, Options> = (
   error: Err,
   response: Res,
   request: Req,
-  options: Options,
+  options: Options
 ) => Err | Promise<Err>;
 
-type ReqInterceptor<Req, Options> = (
-  request: Req,
-  options: Options,
-) => Req | Promise<Req>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
 
 type ResInterceptor<Res, Req, Options> = (
   response: Res,
   request: Req,
-  options: Options,
+  options: Options
 ) => Res | Promise<Res>;
 
 class Interceptors<Interceptor> {
@@ -275,10 +257,7 @@ class Interceptors<Interceptor> {
     return this.fns.indexOf(id);
   }
 
-  update(
-    id: number | Interceptor,
-    fn: Interceptor,
-  ): number | Interceptor | false {
+  update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false {
     const index = this.getInterceptorIndex(id);
     if (this.fns[index]) {
       this.fns[index] = fn;
@@ -327,7 +306,7 @@ const defaultHeaders = {
 };
 
 export const createConfig = <T extends ClientOptions = ClientOptions>(
-  override: Config<Omit<ClientOptions, keyof T> & T> = {},
+  override: Config<Omit<ClientOptions, keyof T> & T> = {}
 ): Config<Omit<ClientOptions, keyof T> & T> => ({
   ...jsonBodySerializer,
   headers: defaultHeaders,

package/client.gen.ts

@@ -1,11 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
-import {
-  type ClientOptions,
-  type Config,
-  createClient,
-  createConfig,
-} from './client/index.js';
+import { type ClientOptions, type Config, createClient, createConfig } from './client/index.js';
 import type { ClientOptions as ClientOptions2 } from './types.gen.js';
 
 /**
@@ -17,7 +12,7 @@ import type { ClientOptions as ClientOptions2 } from './types.gen.js';
  * to ensure your client always has the correct values.
  */
 export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (
-  override?: Config<ClientOptions & T>,
+  override?: Config<ClientOptions & T>
 ) => Config<Required<ClientOptions> & T>;
 
 export const client = createClient(createConfig<ClientOptions2>());

package/core/auth.gen.ts

@@ -21,10 +21,9 @@ export interface Auth {
 
 export const getAuthToken = async (
   auth: Auth,
-  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken
 ): Promise<string | undefined> => {
-  const token =
-    typeof callback === 'function' ? await callback(auth) : callback;
+  const token = typeof callback === 'function' ? await callback(auth) : callback;
 
   if (!token) {
     return;