@vertikalx/vtx-backend-client 1.0.0-dev.8 → 1.0.0-dev.80

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

@@ -4,11 +4,17 @@ exports.VTXBaseAPI = void 0;
 const package_json_1 = require("../../package.json");
 const client_1 = require("../client");
 const api_call_headers_1 = require("./api-call-headers");
+const response_builder_1 = require("./response-builder");
+const domains_1 = require("./domains");
+const vtx_core_common_1 = require("@vertikalx/vtx-core-common");
 class VTXBaseAPI {
     constructor(headers, backendUrl) {
         this.headers = headers ?? api_call_headers_1.DEFAULT_HEADERS;
         this.backendUrl = backendUrl ?? VTXBaseAPI.getDefaultBackendUrl();
     }
+    setHeader(key, value) {
+        this.headers[key] = value;
+    }
     static getDefaultBackendUrl() {
         let retValue = api_call_headers_1.DEFAULT_PROD_URL;
         switch (process.env?.NODE_ENV) {
@@ -46,7 +52,7 @@ class VTXBaseAPI {
         }
         return false;
     }
-    async findNonTenantedUserByEmail(email) {
+    async findUserByEmail(email) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + '/graphql',
             headers: this.headers,
@@ -55,61 +61,35 @@ class VTXBaseAPI {
         let retValue = {};
         try {
             const response = await client.query({
-                nontenantedUserByEmail: {
+                findUserByEmail: {
                     __args: {
                         email: curatedEmail,
                     },
                     _id: true,
                     loginEmail: true,
                     suspended: true,
+                    domains: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
                 },
             });
-            console.log(JSON.stringify(response, null, 2));
-            if (response?.nontenantedUserByEmail?._id) {
-                try {
-                    retValue.data = response.nontenantedUserByEmail;
-                }
-                catch (casterr) {
-                    console.log('Error trying to cast to User');
-                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
-                }
-            }
-            else if (response?.errors) {
-                if (Array.isArray(response.errors)) {
-                    retValue.errors = response.errors;
-                }
-                else {
-                    retValue.errors = [response.errors];
-                }
-            }
-            else if (response?.error) {
-                if (Array.isArray(response.error)) {
-                    retValue.errors = response.error;
-                }
-                else {
-                    retValue.errors = [response.error];
-                }
-            }
-            else {
-                retValue.errors = ['Error: Obtained incorrect data from Backend'];
-            }
+            VTXBaseAPI.Logger.debug('findUserByEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'findUserByEmail', (r) => {
+                const isResponseOk = true && response?.findUserByEmail?._id;
+                return isResponseOk;
+            });
         }
         catch (err1) {
-            try {
-                console.log('ERROR trying to call server');
-                console.log(JSON.stringify(err1, null, 2));
-            }
-            catch (ex) { }
-            if (Array.isArray(err1)) {
-                retValue.errors = err1;
-            }
-            else {
-                retValue.errors = [err1];
-            }
+            VTXBaseAPI.Logger.error('findUserByEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
         }
         return retValue;
     }
-    async createBackendToken_NT(loginEmail) {
+    async loginUserFromEmail(loginEmail, loginMethod = "") {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + '/graphql',
             headers: this.headers,
@@ -118,57 +98,30 @@ class VTXBaseAPI {
         let retValue = {};
         try {
             const response = await client.mutation({
-                createNonTenantUserTokenFromEmail: {
+                loginUserFromEmail: {
                     __args: {
                         email: curatedEmail,
+                        loginMethod: loginMethod
                     },
                     actualToken: true,
                     refreshToken: true,
                 },
             });
-            console.log(JSON.stringify(response, null, 2));
-            if (response?.createNonTenantUserTokenFromEmail?.actualToken) {
-                try {
-                    retValue.data =
-                        response.createNonTenantUserTokenFromEmail;
-                }
-                catch (casterr) {
-                    console.log('Error trying to cast to UserToken:');
-                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
-                }
-            }
-            else if (response?.errors) {
-                if (Array.isArray(response.errors)) {
-                    retValue.errors = response.errors;
-                }
-                else {
-                    retValue.errors = [response.errors];
-                }
-            }
-            else if (response?.error) {
-                if (Array.isArray(response.error)) {
-                    retValue.errors = response.error;
-                }
-                else {
-                    retValue.errors = [response.error];
-                }
-            }
-            else {
-                retValue.errors = ['Error: Obtained incorrect data from Backend'];
-            }
+            VTXBaseAPI.Logger.debug('loginUserFromEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'loginUserFromEmail', (r) => {
+                const isResponseOk = true && response?.loginUserFromEmail?.actualToken;
+                return isResponseOk;
+            });
         }
         catch (err1) {
-            console.log(JSON.stringify(err1, null, 2));
-            if (Array.isArray(err1)) {
-                retValue.errors = err1;
-            }
-            else {
-                retValue.errors = [err1];
-            }
+            VTXBaseAPI.Logger.error('loginUserFromEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
         }
         return retValue;
     }
-    async registerNewUser_NT(loginEmail) {
+    async createUserAndLogin(loginEmail) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + "/graphql",
             headers: this.headers,
@@ -180,7 +133,7 @@ class VTXBaseAPI {
         let retValue = {};
         try {
             const response = await client.mutation({
-                createNonTenantedUserWithLogin: {
+                createUserAndLogin: {
                     __args: {
                         user: payload
                     },
@@ -193,56 +146,4462 @@ class VTXBaseAPI {
                     }
                 }
             });
-            console.log(JSON.stringify(response, null, 2));
-            if (response?.createNonTenantedUserWithLogin?._id) {
-                try {
-                    retValue.data = response.createNonTenantedUserWithLogin;
+            VTXBaseAPI.Logger.debug('createUserAndLogin Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createUserAndLogin', (r) => {
+                const isResponseOk = true && response?.createUserAndLogin?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createUserAndLogin err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerAthlete(payload) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            followStats: {
+                followers: true,
+                followed: true,
+                raves: true,
+                favorites: true
+            },
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            rankings: {
+                worldRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                countryRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                stateRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                cityRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+            },
+            allSports: {
+                _id: true,
+                name: true
+            },
+            teams: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
                 }
-                catch (casterr) {
-                    console.log('Error trying to cast to UserToken:');
-                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            },
+            sponsorBrands: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true,
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
                 }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            preferences: {
+                _id: true,
+                showProfileHelper: true
             }
-            else if (response?.errors) {
-                if (Array.isArray(response.errors)) {
-                    retValue.errors = response.errors;
-                }
-                else {
-                    retValue.errors = [response.errors];
+        };
+        try {
+            const response = await client.mutation({
+                registerAthlete: {
+                    __args: {
+                        input: payload
+                    },
+                    ...fields
                 }
+            });
+            VTXBaseAPI.Logger.debug('registerAthlete Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerAthlete', (r) => {
+                const isResponseOk = true && response?.registerAthlete?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('registerAthlete err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async findBrandByName(name, translations = false) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            let response = null;
+            if (translations) {
+                response = await client.query({
+                    getBrandByName: {
+                        __args: {
+                            name: name,
+                            translations: true
+                        },
+                        _id: true,
+                        name: true,
+                        slogan: true,
+                        website: true,
+                        description: true,
+                        logo: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        banner: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        translations: {
+                            name: true,
+                            slogan: true,
+                            description: true,
+                            language: true
+                        },
+                    }
+                });
+            }
+            else {
+                response = await client.query({
+                    getBrandByName: {
+                        __args: {
+                            name: name,
+                            translations: false
+                        },
+                        _id: true,
+                        name: true,
+                        slogan: true,
+                        website: true,
+                        description: true,
+                        logo: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        banner: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        }
+                    }
+                });
             }
-            else if (response?.error) {
-                if (Array.isArray(response.error)) {
-                    retValue.errors = response.error;
+            VTXBaseAPI.Logger.debug('getBrandByName Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getBrandByName', (r) => {
+                const isResponseOk = true && response?.getBrandByName?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getBrandByName err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createBrand(dto, desiredFields) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = desiredFields ?? { _id: true };
+        try {
+            const response = await client.mutation({
+                createBrand: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
                 }
-                else {
-                    retValue.errors = [response.error];
+            });
+            VTXBaseAPI.Logger.debug('createBrand Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createBrand', (r) => {
+                const isResponseOk = true && response?.createBrand?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createBrand err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createSponsorship(dto, desiredFields) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = desiredFields ?? { _id: true };
+        try {
+            const response = await client.mutation({
+                createSponsorship: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
                 }
-            }
-            else if (response?.data?._id) {
-                try {
-                    retValue.data = response?.data;
+            });
+            VTXBaseAPI.Logger.debug('createSponsorship Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createSponsorship', (r) => {
+                const isResponseOk = true && response?.createSponsorship?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createSponsorship err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getS3UploadUrl(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            uploadUrl: true,
+            fields: {
+                key: true,
+                value: true
+            },
+            downloadUrl: true,
+            bucket: true,
+            key: true
+        };
+        try {
+            const response = await client.query({
+                getUploadUrl: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
                 }
-                catch (casterr) {
-                    console.log('Error trying to cast to UserWithToken:');
-                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            });
+            VTXBaseAPI.Logger.debug('getUploadUrl Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getUploadUrl', (r) => {
+                const isResponseOk = true && ((response?.getUploadUrl?.uploadUrl !== undefined) && (response?.getUploadUrl?.uploadUrl !== null));
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createSponsorship err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async refreshToken(currentToken, refreshToken) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        VTXBaseAPI.Logger.debug('HEADERS:');
+        VTXBaseAPI.Logger.debug(JSON.stringify(this.headers, null, 2));
+        const fields = {
+            actualToken: true,
+            refreshToken: true
+        };
+        const dto = {
+            refreshToken: refreshToken
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                refreshToken: {
+                    __args: {
+                        dto: dto
+                    },
+                    ...fields
                 }
+            });
+            VTXBaseAPI.Logger.debug('refreshToken Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'refreshToken', (r) => {
+                const isResponseOk = true && response?.refreshToken?.refreshToken;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('refreshToken err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerNewDomainTenant(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            email: true,
+            tenant_uri: true,
+            owner: {
+                _id: true,
+                loginEmail: true,
+                suspended: true
+            },
+            domain: {
+                _id: true,
+                name: true,
+                description: true
             }
-            else {
-                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerNewDomainTenant: {
+                    __args: {
+                        tenant: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('registerNewDomainTenant Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerNewDomainTenant', (r) => {
+                const isResponseOk = true && response?.registerNewDomainTenant?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('registerNewDomainTenant err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerNewDomainTenantWithLogin(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            email: true,
+            tenant_uri: true,
+            owner: {
+                _id: true,
+                loginEmail: true,
+                suspended: true
+            },
+            domain: {
+                _id: true,
+                name: true,
+                description: true
+            },
+            user: {
+                _id: true,
+                loginEmail: true,
+                suspended: true,
+                domains: {
+                    _id: true,
+                    name: true,
+                    description: true
+                },
+                token: {
+                    actualToken: true,
+                    refreshToken: true
+                }
             }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerNewDomainTenantWithLogin: {
+                    __args: {
+                        tenant: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('registerNewDomainTenant Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'TenantWithUserLogin', (r) => {
+                const isResponseOk = true && response?.TenantWithUserLogin?._id;
+                return isResponseOk;
+            });
         }
         catch (err1) {
-            console.log(JSON.stringify(err1, null, 2));
-            if (Array.isArray(err1)) {
-                retValue.errors = err1;
+            VTXBaseAPI.Logger.error('registerNewDomainTenantWithLogin err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerUserToDomainFromEmail(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true
+                }
             }
-            else {
-                retValue.errors = [err1];
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerUserToDomainFromEmail: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('registerUserToDomainFromEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerUserToDomainFromEmail', (r) => {
+                const isResponseOk = true && response?.registerUserToDomainFromEmail?.loginEmail;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('registerUserToDomainFromEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getPublicSponsorships() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            title: true,
+            description: true,
+            cashValue: true,
+            otherValue: true,
+            brand: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true
+            },
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            criteria: {
+                _id: true,
+                label: true,
+                qualifications: {
+                    on_AgeQualification: {
+                        type: true,
+                        value: true,
+                        operator: true
+                    },
+                    on_DistanceQualification: {
+                        type: true,
+                        maxDistance: true,
+                        latitude: true,
+                        longitude: true
+                    },
+                    on_GenderQualification: {
+                        type: true,
+                        operator: true,
+                        values: true
+                    },
+                    on_LocationQualification: {
+                        type: true,
+                        operator: true,
+                        countries: {
+                            _id: true,
+                            name: true
+                        },
+                        states: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        cities: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true
+                        }
+                    },
+                    on_NationalityQualification: {
+                        type: true,
+                        operator: true,
+                        countries: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    on_ScoreQualification: {
+                        type: true,
+                        scoreType: true,
+                        operator: true,
+                        value: true
+                    },
+                    on_SportsLevelQualification: {
+                        type: true,
+                        operator: true,
+                        level: true
+                    },
+                    on_SportsQualification: {
+                        type: true,
+                        sports: true,
+                        operator: true
+                    }
+                }
+            },
+            sponsorshipItems: {
+                _id: true,
+                quantity: true,
+                title: true,
+                value: true,
+                type: true
+            },
+            deadline: true,
+            startDate: true,
+            duration: {
+                length: true,
+                unit: true
+            },
+            terms: true,
+            isPrivate: true,
+            stats: {
+                totalApplications: true,
+                newApplications: true,
+                discardedApplications: true,
+                selectedApplications: true,
+                approvedApplications: true,
+                grantedSponsorships: true,
+                remainingSponsorships: true
+            },
+            approved: true,
+            published: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getPublicSponsorships: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getPublicSponsorships Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getPublicSponsorships', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getPublicSponsorships err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getTenantSponsorshipsFromUri(tenantUri, token) {
+        if ((!tenantUri) || (tenantUri.trim() === "")) {
+            return {
+                error: {
+                    httpStatus: 400,
+                    code: vtx_core_common_1.VTX_ERRORS.INVALID_TENANT_URI.code,
+                    message: vtx_core_common_1.VTX_ERRORS.INVALID_TENANT_URI.description
+                }
+            };
+        }
+        const credential = token.domains.find(c => {
+            if (c.tenant) {
+                if ((c.tenant.tenant_uri == tenantUri) && (c._id == domains_1.DOMAIN_SPONSOR)) {
+                    return true;
+                }
             }
+            return false;
+        });
+        if (!credential) {
+            return {
+                error: {
+                    httpStatus: 400,
+                    code: vtx_core_common_1.VTX_ERRORS.INVALID_TENANT_URI_FOR_SPONSOR.code,
+                    message: "Tenant in domain SPONSOR not found in domains with URI " + tenantUri
+                }
+            };
+        }
+        const tenantId = credential.tenant?._id ?? null;
+        if ((!tenantId) || (tenantId == "ALL")) {
+            return {
+                error: {
+                    httpStatus: 400,
+                    code: vtx_core_common_1.VTX_ERRORS.INVALID_TENANT_ID.code,
+                    message: vtx_core_common_1.VTX_ERRORS.INVALID_TENANT_ID.description
+                }
+            };
+        }
+        return this.getTenantSponsorships(tenantId);
+    }
+    async getTenantSponsorships(tenantId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            title: true,
+            description: true,
+            cashValue: true,
+            otherValue: true,
+            brand: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true
+            },
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            criteria: {
+                _id: true,
+                label: true,
+                qualifications: {
+                    on_AgeQualification: {
+                        type: true,
+                        value: true,
+                        operator: true
+                    },
+                    on_DistanceQualification: {
+                        type: true,
+                        maxDistance: true,
+                        latitude: true,
+                        longitude: true
+                    },
+                    on_GenderQualification: {
+                        type: true,
+                        operator: true,
+                        values: true
+                    },
+                    on_LocationQualification: {
+                        type: true,
+                        operator: true,
+                        countries: {
+                            _id: true,
+                            name: true
+                        },
+                        states: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        cities: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true
+                        }
+                    },
+                    on_NationalityQualification: {
+                        type: true,
+                        operator: true,
+                        countries: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    on_ScoreQualification: {
+                        type: true,
+                        scoreType: true,
+                        operator: true,
+                        value: true
+                    },
+                    on_SportsLevelQualification: {
+                        type: true,
+                        operator: true,
+                        level: true
+                    },
+                    on_SportsQualification: {
+                        type: true,
+                        sports: true,
+                        operator: true
+                    }
+                }
+            },
+            sponsorshipItems: {
+                _id: true,
+                quantity: true,
+                title: true,
+                value: true,
+                type: true
+            },
+            deadline: true,
+            startDate: true,
+            duration: {
+                length: true,
+                unit: true
+            },
+            terms: true,
+            isPrivate: true,
+            stats: {
+                totalApplications: true,
+                newApplications: true,
+                discardedApplications: true,
+                selectedApplications: true,
+                approvedApplications: true,
+                grantedSponsorships: true,
+                remainingSponsorships: true
+            },
+            approved: true,
+            published: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getTenantSponsorships: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getTenantSponsorships Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getTenantSponsorships', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getTenantSponsorships err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async sendAthleteInvitations(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            email: true,
+            dateSent: true,
+            sponsor: {
+                _id: true,
+                name: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true
+                }
+            },
+            magicLink: {
+                _id: true,
+                code: true,
+                type: true,
+                url: true,
+                expires: true,
+                data: true,
+                isExpired: true
+            },
+            brand: {
+                _id: true,
+                name: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    url: true,
+                    useType: true
+                },
+                website: true
+            },
+            status: true
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                sendAthleteInvitations: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('sendAthleteInvitations Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'sendAthleteInvitations', (r) => {
+                const isResponseOk = true && Array.isArray(response?.sendAthleteInvitations);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('sendAthleteInvitations err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerSponsorUser(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerSponsorUser: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('registerSponsorUser Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerSponsorUser', (r) => {
+                const isResponseOk = true && response?.registerSponsorUser._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('registerSponsorUser err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerAthleteUser(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerAthleteUser: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('registerAthleteUser Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerAthleteUser', (r) => {
+                const isResponseOk = true && response?.registerAthleteUser._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('registerAthleteUser err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async preRegisterAthleteUser(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            type: true,
+            recipient: true,
+            expires: true,
+            isExpired: true,
+            createdDate: true
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                preRegisterAthleteUser: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('preRegisterAthleteUser Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'preRegisterAthleteUser', (r) => {
+                const isResponseOk = true && response?.preRegisterAthleteUser._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('preRegisterAthleteUser err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async confirmAthleteUserRegistrationAndLogin(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            },
+            token: {
+                actualToken: true,
+                refreshToken: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                confirmAthleteUserRegistrationAndLogin: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('confirmAthleteUserRegistrationAndLogin Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'confirmAthleteUserRegistrationAndLogin', (r) => {
+                const isResponseOk = true && response?.confirmAthleteUserRegistrationAndLogin._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('confirmAthleteUserRegistrationAndLogin err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async confirmAthleteUserRegistration(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                confirmAthleteUserRegistration: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('confirmAthleteUserRegistration Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'confirmAthleteUserRegistration', (r) => {
+                const isResponseOk = true && response?.confirmAthleteUserRegistration._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('confirmAthleteUserRegistration err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async findSponsorAthleteInvitation(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            email: true,
+            dateSent: true,
+            sponsor: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true
+            },
+            magicLink: {
+                _id: true,
+                code: true,
+                type: true,
+                url: true,
+                expires: true,
+                isExpired: true
+            },
+            brand: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            status: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                findSponsorAthleteInvitation: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('findSponsorAthleteInvitation Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'findSponsorAthleteInvitation', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && response?.findSponsorAthleteInvitation?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('findSponsorAthleteInvitation err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async findVtxUser(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                findVtxUser: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('findVtxUser Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'findVtxUser', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && response?.findVtxUser?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('findVtxUser err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async findCitiesStartingWith(pattern) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            localizedName: true,
+            state: {
+                _id: true,
+                name: true,
+                country: {
+                    _id: true,
+                    name: true
+                }
+            },
+            latitude: true,
+            longitude: true,
+            timezone: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                findCitiesStartingWith: {
+                    __args: {
+                        text: pattern
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('findCitiesStartingWith Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'findCitiesStartingWith', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.findCitiesStartingWith);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('findCitiesStartingWith err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async findCityById(cityId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            localizedName: true,
+            state: {
+                _id: true,
+                name: true,
+                country: {
+                    _id: true,
+                    name: true
+                }
+            },
+            latitude: true,
+            longitude: true,
+            timezone: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                findCityById: {
+                    __args: {
+                        cityId: cityId
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('findCityById Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'findCityById', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && response?.findCityById?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('findCityById err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getSportLevels() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            label: true,
+            index: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getSportLevels: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getSportLevels Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getSportLevels', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getSportLevels);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getSportLevels err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getSports() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getSports: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getSports Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getSports', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getSports);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getSports err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async loginUserFromCredentialsVtx(username, password) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        const curatedEmail = username.trim().toLocaleLowerCase();
+        let retValue = {};
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            },
+            loginMethods: true,
+            token: {
+                actualToken: true,
+                refreshToken: true
+            }
+        };
+        try {
+            const response = await client.mutation({
+                loginUserFromCredentialsVtx: {
+                    __args: {
+                        username: curatedEmail,
+                        password: password
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('loginUserFromCredentialsVtx Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'loginUserFromCredentialsVtx', (r) => {
+                const isResponseOk = true && response?.loginUserFromCredentialsVtx?.actualToken;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('loginUserFromCredentialsVtx err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async validateUserCredentialsVtx(username, password) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        const curatedEmail = username.trim().toLocaleLowerCase();
+        let retValue = {};
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true,
+                    domain: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                }
+            },
+            loginMethods: true
+        };
+        try {
+            const response = await client.query({
+                validateUserCredentials: {
+                    __args: {
+                        username: curatedEmail,
+                        password: password
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('validateUserCredentials Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'validateUserCredentials', (r) => {
+                const isResponseOk = true && response?.validateUserCredentials?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('validateUserCredentials err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async findAthleteForUser(loginEmail) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            followStats: {
+                followers: true,
+                followed: true,
+                raves: true,
+                favorites: true
+            },
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            rankings: {
+                worldRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                countryRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                stateRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                cityRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+            },
+            allSports: {
+                _id: true,
+                name: true
+            },
+            teams: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            sponsorBrands: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true,
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            preferences: {
+                _id: true,
+                showProfileHelper: true
+            },
+            currentCampaign: {
+                _id: true,
+                budgetMode: true,
+                status: true,
+                title: true,
+                motivation: true,
+                website: true,
+                fundsRequired: true,
+                initialFundsObtained: true,
+                fundsObtained: true,
+                location: {
+                    _id: true,
+                    userProvidedLatitude: true,
+                    userProvidedLongitude: true,
+                    cityNameGeocode: true,
+                    stateNameGeocode: true,
+                    countryIso2CodeGeocode: true,
+                    timeZoneGeocode: true,
+                    latitudeGeocode: true,
+                    longitudeGeocode: true,
+                    city: {
+                        _id: true,
+                        name: true,
+                        localizedName: true,
+                        state: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        latitude: true,
+                        longitude: true,
+                        timezone: true,
+                    }
+                },
+                endingDate: true,
+                budget: {
+                    _id: true,
+                    initialFunds: true,
+                    totalRequired: true,
+                    items: {
+                        _id: true,
+                        quantity: true,
+                        concept: true,
+                        itemCost: true
+                    }
+                },
+                competitions: {
+                    _id: true,
+                    event: {
+                        _id: true,
+                        name: true,
+                        mainSport: {
+                            _id: true,
+                            name: true
+                        },
+                        eventWebSite: true,
+                        startDate: true,
+                        endDate: true,
+                        verified: true,
+                        banner: {
+                            _id: true,
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        location: {
+                            _id: true,
+                            userProvidedLatitude: true,
+                            userProvidedLongitude: true,
+                            cityNameGeocode: true,
+                            stateNameGeocode: true,
+                            countryIso2CodeGeocode: true,
+                            timeZoneGeocode: true,
+                            latitudeGeocode: true,
+                            longitudeGeocode: true,
+                            city: {
+                                _id: true,
+                                name: true,
+                                localizedName: true,
+                                state: {
+                                    _id: true,
+                                    name: true,
+                                    country: {
+                                        _id: true,
+                                        name: true
+                                    }
+                                },
+                                latitude: true,
+                                longitude: true,
+                                timezone: true,
+                            }
+                        },
+                    },
+                    participationDate: true,
+                    result: {
+                        _id: true,
+                        resultType: true,
+                        position: true,
+                        score: true,
+                        finishTimeMS: true,
+                        resultWebLink: true
+                    }
+                }
+            }
+        };
+        try {
+            let response = null;
+            response = await client.query({
+                findAthleteForUser: {
+                    __args: {
+                        loginEmail: loginEmail
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('findAthleteForUser Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'findAthleteForUser', (r) => {
+                const isResponseOk = true && response?.findAthleteForUser?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('findAthleteForUser err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getBrands() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            slogan: true,
+            website: true,
+            description: true,
+            approved: true,
+            published: true,
+            logo: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            stats: {
+                campaigns: true,
+                sponsorships: true,
+                sports: true,
+                athletes: true
+            },
+            operatorIds: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                brands: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('brands Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'brands', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.brands);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('brands err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getAthletes() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            followStats: {
+                followers: true,
+                followed: true,
+                raves: true,
+                favorites: true
+            },
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            rankings: {
+                worldRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                countryRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                stateRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                cityRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+            },
+            allSports: {
+                _id: true,
+                name: true
+            },
+            teams: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            sponsorBrands: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true,
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            preferences: {
+                _id: true,
+                showProfileHelper: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getAthletes: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getAthletes Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getAthletes', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getAthletes);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getAthletes err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async searchAthletes(searchString) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            followStats: {
+                followers: true,
+                followed: true,
+                raves: true,
+                favorites: true
+            },
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            rankings: {
+                worldRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                countryRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                stateRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                cityRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+            },
+            allSports: {
+                _id: true,
+                name: true
+            },
+            teams: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            sponsorBrands: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true,
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            preferences: {
+                _id: true,
+                showProfileHelper: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                searchAthletes: {
+                    __args: {
+                        searchString: searchString
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('searchAthletes Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'searchAthletes', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.searchAthletes);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('searchAthletes err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getRecommendedAthletes(loginEmail) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            followStats: {
+                followers: true,
+                followed: true,
+                raves: true,
+                favorites: true
+            },
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            rankings: {
+                worldRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                countryRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                stateRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                cityRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+            },
+            allSports: {
+                _id: true,
+                name: true
+            },
+            teams: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            sponsorBrands: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true,
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            preferences: {
+                _id: true,
+                showProfileHelper: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getRecommendedAthletes: {
+                    __args: {
+                        loginEmail: loginEmail
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getRecommendedAthletes Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getRecommendedAthletes', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getRecommendedAthletes);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getRecommendedAthletes err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getSponsorAthletesForTenant() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            followStats: {
+                followers: true,
+                followed: true,
+                raves: true,
+                favorites: true
+            },
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            rankings: {
+                worldRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                countryRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                stateRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+                cityRanking: {
+                    scope: true,
+                    scopeId: true,
+                    scopeName: true,
+                    position: true,
+                    total: true
+                },
+            },
+            allSports: {
+                _id: true,
+                name: true
+            },
+            teams: {
+                _id: true,
+                name: true,
+                description: true,
+                approved: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            sponsorBrands: {
+                _id: true,
+                name: true,
+                slogan: true,
+                website: true,
+                description: true,
+                approved: true,
+                published: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                stats: {
+                    campaigns: true,
+                    sponsorships: true,
+                    sports: true,
+                    athletes: true
+                },
+                operatorIds: true,
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            preferences: {
+                _id: true,
+                showProfileHelper: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getSponsorAthletesForTenant: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getSponsorAthletesForTenant Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getSponsorAthletesForTenant', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getSponsorAthletesForTenant);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getSponsorAthletesForTenant err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getUserImagesFromEmail(loginEmail) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            profilePictureUrl: true,
+            cardPictureUrl: true,
+            bannerPictureUrl: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getUserImagesFromEmail: {
+                    __args: {
+                        loginEmail: loginEmail
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getUserImagesFromEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getUserImagesFromEmail', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && response?.getUserImagesFromEmail;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getUserImagesFromEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async editAboutMe(newValue) {
+        console.log('HEADERS:');
+        console.log(JSON.stringify(this.headers, null, 2));
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            field: true,
+            oldValue: true,
+            newValue: true,
+            changed: true
+        };
+        const dto = {
+            field: 'aboutMe',
+            newValue: newValue
+        };
+        try {
+            const response = await client.mutation({
+                editProfileValue: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('editProfileValue Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'editProfileValue', (r) => {
+                const isResponseOk = true && response?.editProfileValue?.field;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('editProfileValue err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async editProfileValue(newValue, field) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            field: true,
+            oldValue: true,
+            newValue: true,
+            changed: true
+        };
+        const dto = {
+            field: field,
+            newValue: newValue
+        };
+        try {
+            const response = await client.mutation({
+                editProfileValue: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('editProfileValue Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'editProfileValue', (r) => {
+                const isResponseOk = true && response?.editProfileValue?.field;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('editProfileValue err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async addAthleteCompetition(dto) {
+        console.log('HEADERS:');
+        console.log(JSON.stringify(this.headers, null, 2));
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            _id: true,
+            event: {
+                _id: true,
+                name: true,
+                mainSport: {
+                    _id: true,
+                    name: true
+                },
+                eventWebSite: true,
+                startDate: true,
+                endDate: true,
+                verified: true,
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                location: {
+                    _id: true,
+                    userProvidedLatitude: true,
+                    userProvidedLongitude: true,
+                    cityNameGeocode: true,
+                    stateNameGeocode: true,
+                    countryIso2CodeGeocode: true,
+                    timeZoneGeocode: true,
+                    latitudeGeocode: true,
+                    longitudeGeocode: true,
+                    city: {
+                        _id: true,
+                        name: true,
+                        localizedName: true,
+                        state: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        latitude: true,
+                        longitude: true,
+                        timezone: true,
+                    }
+                },
+            },
+            participationDate: true,
+            competitionNumber: true,
+            result: {
+                resultType: true,
+                position: true,
+                score: true,
+                finishTimeMS: true,
+                resultWebLink: true
+            },
+            fundRaisingCampaignIds: true
+        };
+        try {
+            const response = await client.mutation({
+                addAthleteCompetition: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('addAthleteCompetition Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'addAthleteCompetition', (r) => {
+                const isResponseOk = true && response?.addAthleteCompetition?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('addAthleteCompetition err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getSportsEvents(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            eventWebSite: true,
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            startDate: true,
+            endDate: true,
+            verified: true,
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            location: {
+                _id: true,
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getSportsEvents: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getSportsEvents Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getSportsEvents', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getSportsEvents);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getSportsEvents err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createSportsEvent(dto) {
+        console.log('HEADERS:');
+        console.log(JSON.stringify(this.headers, null, 2));
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            _id: true,
+            name: true,
+            eventWebSite: true,
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            startDate: true,
+            endDate: true,
+            verified: true,
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            location: {
+                _id: true,
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            }
+        };
+        try {
+            const response = await client.mutation({
+                createSportsEvent: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('createSportsEvent Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createSportsEvent', (r) => {
+                const isResponseOk = true && response?.createSportsEvent?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createSportsEvent err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getAthleteCompetitions(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            event: {
+                _id: true,
+                name: true,
+                mainSport: {
+                    _id: true,
+                    name: true
+                },
+                eventWebSite: true,
+                startDate: true,
+                endDate: true,
+                verified: true,
+                banner: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                location: {
+                    _id: true,
+                    userProvidedLatitude: true,
+                    userProvidedLongitude: true,
+                    cityNameGeocode: true,
+                    stateNameGeocode: true,
+                    countryIso2CodeGeocode: true,
+                    timeZoneGeocode: true,
+                    latitudeGeocode: true,
+                    longitudeGeocode: true,
+                    city: {
+                        _id: true,
+                        name: true,
+                        localizedName: true,
+                        state: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        latitude: true,
+                        longitude: true,
+                        timezone: true,
+                    }
+                },
+            },
+            participationDate: true,
+            competitionNumber: true,
+            result: {
+                resultType: true,
+                position: true,
+                score: true,
+                finishTimeMS: true,
+                resultWebLink: true
+            },
+            fundRaisingCampaignIds: true,
+            budget: {
+                _id: true,
+                totalRequired: true,
+                initialFunds: true,
+                items: {
+                    _id: true,
+                    quantity: true,
+                    concept: true,
+                    itemCost: true
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getAthleteCompetitions: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getSportsEvents Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getAthleteCompetitions', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getAthleteCompetitions);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getAthleteCompetitions err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getAthleteMemberships(athleteId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            organization: {
+                _id: true,
+                shortName: true,
+                acronym: true,
+                fullName: true,
+                website: true,
+                verified: true,
+                logo: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                country: {
+                    _id: true,
+                    name: true
+                },
+                sport: {
+                    _id: true,
+                    name: true
+                }
+            },
+            athlete: {
+                _id: true,
+                firstName: true,
+                lastName: true,
+                screenName: true,
+                dob: true,
+                lgbt: true,
+                competitionGender: true,
+                country: {
+                    _id: true,
+                    name: true
+                },
+                location: {
+                    userProvidedLatitude: true,
+                    userProvidedLongitude: true,
+                    cityNameGeocode: true,
+                    stateNameGeocode: true,
+                    countryIso2CodeGeocode: true,
+                    timeZoneGeocode: true,
+                    latitudeGeocode: true,
+                    longitudeGeocode: true,
+                    city: {
+                        _id: true,
+                        name: true,
+                        localizedName: true,
+                        state: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        latitude: true,
+                        longitude: true,
+                        timezone: true,
+                    }
+                },
+                trainer: true,
+                trainerUrl: true,
+                aboutMe: true,
+                followStats: {
+                    followers: true,
+                    followed: true,
+                    raves: true,
+                    favorites: true
+                },
+                mainSport: {
+                    _id: true,
+                    name: true
+                },
+                mainSportLevel: {
+                    _id: true,
+                    label: true,
+                    index: true
+                },
+                scores: {
+                    vtxScore: true,
+                    socialScore: true,
+                    trainingScore: true,
+                    competitionScore: true
+                },
+                rankings: {
+                    worldRanking: {
+                        scope: true,
+                        scopeId: true,
+                        scopeName: true,
+                        position: true,
+                        total: true
+                    },
+                    countryRanking: {
+                        scope: true,
+                        scopeId: true,
+                        scopeName: true,
+                        position: true,
+                        total: true
+                    },
+                    stateRanking: {
+                        scope: true,
+                        scopeId: true,
+                        scopeName: true,
+                        position: true,
+                        total: true
+                    },
+                    cityRanking: {
+                        scope: true,
+                        scopeId: true,
+                        scopeName: true,
+                        position: true,
+                        total: true
+                    },
+                },
+                totalUpcomingCompetitions: true,
+                totalPastCompetitions: true,
+                profilePicture: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
+                cardPicture: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                }
+            },
+            membershipNumber: true,
+            membershipType: true,
+            issueDate: true,
+            expirationDate: true
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getAthleteMemberships: {
+                    __args: {
+                        athleteId: athleteId
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getAthleteMemberships Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getAthleteMemberships', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getAthleteMemberships);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getAthleteMemberships err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async deleteAthleteCompetition(dto) {
+        console.log('HEADERS:');
+        console.log(JSON.stringify(this.headers, null, 2));
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            idToDelete: true,
+            deleted: true,
+            failureReason: {
+                code: true,
+                message: true
+            }
+        };
+        try {
+            const response = await client.mutation({
+                deleteAthleteCompetition: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.debug('deleteAthleteCompetition Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'deleteAthleteCompetition', (r) => {
+                const isResponseOk = true && response?.deleteAthleteCompetition?.idToDelete;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('deleteAthleteCompetition err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createFundingCampaign(dto) {
+        console.log('HEADERS:');
+        console.log(JSON.stringify(this.headers, null, 2));
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            _id: true,
+            budgetMode: true,
+            status: true,
+            title: true,
+            motivation: true,
+            website: true,
+            fundsRequired: true,
+            initialFundsObtained: true,
+            fundsObtained: true,
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            endingDate: true,
+            budget: {
+                initialFunds: true,
+                totalRequired: true,
+                items: {
+                    _id: true,
+                    quantity: true,
+                    concept: true,
+                    itemCost: true
+                }
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                competitionNumber: true,
+                result: {
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                },
+                fundRaisingCampaignIds: true
+            }
+        };
+        try {
+            const response = await client.mutation({
+                createFundingCampaign: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                },
+            });
+            VTXBaseAPI.Logger.log("==================HERE=====================================");
+            VTXBaseAPI.Logger.log('createFundingCampaign Response:');
+            VTXBaseAPI.Logger.log(JSON.stringify(response, null, 2));
+            VTXBaseAPI.Logger.log("==================DONE=====================================");
+            retValue = (0, response_builder_1.buildResponse)(response, 'createFundingCampaign', (r) => {
+                const isResponseOk = true && response?.createFundingCampaign?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.log("************** ERROR *******************************");
+            VTXBaseAPI.Logger.log('createFundingCampaign err1:');
+            VTXBaseAPI.Logger.log(err1);
+            VTXBaseAPI.Logger.log("************** DONE ERROR **************************");
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createMembershipOrganization(dto, desiredFields) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = desiredFields ?? { _id: true };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                createMembershipOrganization: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('createMembershipOrganization Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createMembershipOrganization', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && response?.createMembershipOrganization?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createMembershipOrganization err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getMembershipOrganizations() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            shortName: true,
+            acronym: true,
+            fullName: true,
+            website: true,
+            verified: true,
+            logo: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            country: {
+                _id: true,
+                name: true
+            },
+            sport: {
+                _id: true,
+                name: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getMembershipOrganizations: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getMembershipOrganizations Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getMembershipOrganizations', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.getMembershipOrganizations);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getMembershipOrganizations err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createAthleteMembershipAffilation(dto, desiredFields) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = desiredFields ?? { _id: true };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                createAthleteMembershipAffilation: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('createAthleteMembershipAffilation Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createAthleteMembershipAffilation', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && response?.createAthleteMembershipAffilation?._id;
+                return isResponseOk;
+            });
+        }
+        catch (error1) {
+            VTXBaseAPI.Logger.error('createAthleteMembershipAffilation err1:');
+            VTXBaseAPI.Logger.error(error1);
+            retValue = (0, response_builder_1.buildErrorResponse)(error1);
+        }
+        return retValue;
+    }
+    async queryAthleteFundingCampaigns(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fieldsAthlete = {
+            _id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            dob: true,
+            lgbt: true,
+            competitionGender: true,
+            country: {
+                _id: true,
+                name: true
+            },
+            location: {
+                userProvidedLatitude: true,
+                userProvidedLongitude: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                timeZoneGeocode: true,
+                latitudeGeocode: true,
+                longitudeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    localizedName: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true
+                        }
+                    },
+                    latitude: true,
+                    longitude: true,
+                    timezone: true,
+                }
+            },
+            trainer: true,
+            trainerUrl: true,
+            aboutMe: true,
+            mainSport: {
+                _id: true,
+                name: true
+            },
+            mainSportLevel: {
+                _id: true,
+                label: true,
+                index: true
+            },
+            scores: {
+                vtxScore: true,
+                socialScore: true,
+                trainingScore: true,
+                competitionScore: true
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                    mainSport: {
+                        _id: true,
+                        name: true
+                    },
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    },
+                    location: {
+                        _id: true,
+                        userProvidedLatitude: true,
+                        userProvidedLongitude: true,
+                        cityNameGeocode: true,
+                        stateNameGeocode: true,
+                        countryIso2CodeGeocode: true,
+                        timeZoneGeocode: true,
+                        latitudeGeocode: true,
+                        longitudeGeocode: true,
+                        city: {
+                            _id: true,
+                            name: true,
+                            localizedName: true,
+                            state: {
+                                _id: true,
+                                name: true,
+                                country: {
+                                    _id: true,
+                                    name: true
+                                }
+                            },
+                            latitude: true,
+                            longitude: true,
+                            timezone: true,
+                        }
+                    },
+                },
+                participationDate: true,
+                result: {
+                    _id: true,
+                    resultType: true,
+                    position: true,
+                    score: true,
+                    finishTimeMS: true,
+                    resultWebLink: true
+                }
+            },
+            totalUpcomingCompetitions: true,
+            totalPastCompetitions: true,
+            profilePicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            cardPicture: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            currentCampaign: {
+                _id: true,
+                budgetMode: true,
+                status: true,
+                title: true,
+                motivation: true,
+                website: true,
+                fundsRequired: true,
+                initialFundsObtained: true,
+                fundsObtained: true,
+                location: {
+                    _id: true,
+                    userProvidedLatitude: true,
+                    userProvidedLongitude: true,
+                    cityNameGeocode: true,
+                    stateNameGeocode: true,
+                    countryIso2CodeGeocode: true,
+                    timeZoneGeocode: true,
+                    latitudeGeocode: true,
+                    longitudeGeocode: true,
+                    city: {
+                        _id: true,
+                        name: true,
+                        localizedName: true,
+                        state: {
+                            _id: true,
+                            name: true,
+                            country: {
+                                _id: true,
+                                name: true
+                            }
+                        },
+                        latitude: true,
+                        longitude: true,
+                        timezone: true,
+                    }
+                },
+                endingDate: true,
+                budget: {
+                    _id: true,
+                    initialFunds: true,
+                    totalRequired: true,
+                    items: {
+                        _id: true,
+                        quantity: true,
+                        concept: true,
+                        itemCost: true
+                    }
+                },
+                competitions: {
+                    _id: true,
+                    event: {
+                        _id: true,
+                        name: true,
+                        mainSport: {
+                            _id: true,
+                            name: true
+                        },
+                        eventWebSite: true,
+                        startDate: true,
+                        endDate: true,
+                        verified: true,
+                        banner: {
+                            _id: true,
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        location: {
+                            _id: true,
+                            userProvidedLatitude: true,
+                            userProvidedLongitude: true,
+                            cityNameGeocode: true,
+                            stateNameGeocode: true,
+                            countryIso2CodeGeocode: true,
+                            timeZoneGeocode: true,
+                            latitudeGeocode: true,
+                            longitudeGeocode: true,
+                            city: {
+                                _id: true,
+                                name: true,
+                                localizedName: true,
+                                state: {
+                                    _id: true,
+                                    name: true,
+                                    country: {
+                                        _id: true,
+                                        name: true
+                                    }
+                                },
+                                latitude: true,
+                                longitude: true,
+                                timezone: true,
+                            }
+                        },
+                    },
+                    participationDate: true,
+                    result: {
+                        _id: true,
+                        resultType: true,
+                        position: true,
+                        score: true,
+                        finishTimeMS: true,
+                        resultWebLink: true
+                    }
+                }
+            }
+        };
+        const fields = {
+            athletes: fieldsAthlete,
+            cursor: {
+                sort: {
+                    sortField: true,
+                    order: true
+                },
+                initialCursorId: true,
+                nextCursorId: true,
+                initialCursorValue: true,
+                nextCursorValue: true,
+                limit: true,
+                retrieved: true,
+                isLastPage: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                queryAthleteFundingCampaigns: {
+                    __args: { input: dto },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('queryAthleteFundingCampaigns Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'queryAthleteFundingCampaigns', (r) => {
+                VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+                const isResponseOk = true && Array.isArray(response?.queryAthleteFundingCampaigns?.athletes);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('queryAthleteFundingCampaigns err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
         }
         return retValue;
     }
 }
 exports.VTXBaseAPI = VTXBaseAPI;
+VTXBaseAPI.Logger = {
+    debug: (str) => {
+    },
+    log: (str) => {
+        console.log(str);
+    },
+    warn: (str) => {
+    },
+    error: (str) => {
+    },
+};
 //# sourceMappingURL=vtx-base-api.js.map