@vertikalx/vtx-backend-client 1.0.0-dev.5 → 1.0.0-dev.50

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, system) {
+    async findUserByEmail(email) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + '/graphql',
             headers: this.headers,
@@ -55,60 +61,3032 @@ 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
+                    }
+                },
+            });
+            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) {
+            VTXBaseAPI.Logger.error('findUserByEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async loginUserFromEmail(loginEmail, loginMethod = "") {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        const curatedEmail = loginEmail.trim().toLocaleLowerCase();
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                loginUserFromEmail: {
+                    __args: {
+                        email: curatedEmail,
+                        loginMethod: loginMethod
+                    },
+                    actualToken: true,
+                    refreshToken: true,
                 },
             });
-            console.log(JSON.stringify(response, null, 2));
-            if (response?.nontenantedUserByEmail?._id) {
-                try {
-                    retValue.data = response.nontenantedUserByEmail;
+            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) {
+            VTXBaseAPI.Logger.error('loginUserFromEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createUserAndLogin(loginEmail) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const curatedEmail = loginEmail.trim().toLowerCase();
+        const payload = {
+            loginEmail: curatedEmail
+        };
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                createUserAndLogin: {
+                    __args: {
+                        user: payload
+                    },
+                    _id: true,
+                    loginEmail: true,
+                    suspended: true,
+                    token: {
+                        actualToken: true,
+                        refreshToken: true
+                    }
                 }
-                catch (casterr) {
-                    console.log('Error trying to cast to User');
-                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            });
+            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,
                 }
-            }
-            else if (response?.errors) {
-                if (Array.isArray(response.errors)) {
-                    retValue.errors = response.errors;
+            },
+            trainer: true,
+            trainerUrl: 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
                 }
-                else {
-                    retValue.errors = [response.errors];
+            },
+            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,
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                eventName: true,
+                date: true,
+                result: {
+                    _id: true,
+                    type: true,
+                    position: true,
+                    score: true,
+                    timems: 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
             }
-            else if (response?.error) {
-                if (Array.isArray(response.error)) {
-                    retValue.errors = response.error;
-                }
-                else {
-                    retValue.errors = [response.error];
+        };
+        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 {
-                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                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
+                        }
+                    }
+                });
+            }
+            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
+                }
+            });
+            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
+                }
+            });
+            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
+                }
+            });
+            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
             }
+        };
+        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) {
-            try {
-                console.log('ERROR trying to call server');
-                console.log(JSON.stringify(err1, null, 2));
+            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
+                }
             }
-            catch (ex) { }
-            if (Array.isArray(err1)) {
-                retValue.errors = err1;
+        };
+        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) {
+            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,
+            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,
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                eventName: true,
+                date: true,
+                result: {
+                    _id: true,
+                    type: true,
+                    position: true,
+                    score: true,
+                    timems: 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
+            }
+        };
+        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,
+            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,
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                eventName: true,
+                date: true,
+                result: {
+                    _id: true,
+                    type: true,
+                    position: true,
+                    score: true,
+                    timems: 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
+            }
+        };
+        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,
+            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,
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                eventName: true,
+                date: true,
+                result: {
+                    _id: true,
+                    type: true,
+                    position: true,
+                    score: true,
+                    timems: 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
+            }
+        };
+        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,
+            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,
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                eventName: true,
+                date: true,
+                result: {
+                    _id: true,
+                    type: true,
+                    position: true,
+                    score: true,
+                    timems: 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
+            }
+        };
+        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,
+            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,
+                    eventWebSite: true,
+                    startDate: true,
+                    endDate: true,
+                    verified: true,
+                    banner: {
+                        _id: true,
+                        name: true,
+                        contentType: true,
+                        size: true,
+                        useType: true,
+                        url: true,
+                        key: true
+                    }
+                },
+                eventName: true,
+                date: true,
+                result: {
+                    _id: true,
+                    type: true,
+                    position: true,
+                    score: true,
+                    timems: 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
+            }
+        };
+        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;
     }
 }
 exports.VTXBaseAPI = VTXBaseAPI;
+VTXBaseAPI.Logger = {
+    debug: (str) => {
+    },
+    log: (str) => {
+    },
+    warn: (str) => {
+    },
+    error: (str) => {
+        console.error(str);
+    },
+};
 //# sourceMappingURL=vtx-base-api.js.map