@vertikalx/vtx-backend-client 3.0.0-dev.32 → 3.0.0-dev.34

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

@@ -2148,6 +2148,8 @@ class VTXBaseAPI {
             trainerUrl: true,
             aboutMe: true,
             biography: true,
+            onboardingComplete: true,
+            onboardingStep: true,
             followStats: {
                 followers: true,
                 followed: true,
@@ -2375,6 +2377,7 @@ class VTXBaseAPI {
             },
             currentCampaign: {
                 _id: true,
+                slug: true,
                 budgetMode: true,
                 status: true,
                 title: true,
@@ -2383,12 +2386,22 @@ class VTXBaseAPI {
                 fundsRequired: true,
                 initialFundsObtained: true,
                 fundsObtained: true,
+                vtxComissionPct: true,
                 video: {
                     _id: true,
                     source: true,
                     url: true,
                     sourceData: true
                 },
+                coverImage: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
                 location: {
                     _id: true,
                     userProvidedLatitude: true,
@@ -5123,6 +5136,7 @@ class VTXBaseAPI {
             },
             currentCampaign: {
                 _id: true,
+                slug: true,
                 budgetMode: true,
                 status: true,
                 title: true,
@@ -5137,6 +5151,15 @@ class VTXBaseAPI {
                     url: true,
                     sourceData: true
                 },
+                coverImage: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
                 endingDate: true,
                 competitions: {
                     _id: true,
@@ -6101,6 +6124,7 @@ class VTXBaseAPI {
             },
             currentCampaign: {
                 _id: true,
+                slug: true,
                 budgetMode: true,
                 status: true,
                 title: true,
@@ -6109,12 +6133,22 @@ class VTXBaseAPI {
                 fundsRequired: true,
                 initialFundsObtained: true,
                 fundsObtained: true,
+                vtxComissionPct: true,
                 video: {
                     _id: true,
                     source: true,
                     url: true,
                     sourceData: true
                 },
+                coverImage: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
                 location: {
                     _id: true,
                     userProvidedLatitude: true,
@@ -6914,8 +6948,7 @@ class VTXBaseAPI {
             console.log('getAthleteAlbums Response:');
             console.log(JSON.stringify(response, null, 2));
             retValue = (0, response_builder_1.buildResponse)(response, 'getAthleteAlbums', (r) => {
-                const isResponseOk = response?.getAthleteAlbums.length > 0;
-                return isResponseOk;
+                return Array.isArray(response?.getAthleteAlbums);
             });
         }
         catch (err1) {
@@ -7189,6 +7222,7 @@ class VTXBaseAPI {
             },
             currentCampaign: {
                 _id: true,
+                slug: true,
                 budgetMode: true,
                 status: true,
                 title: true,
@@ -7197,12 +7231,22 @@ class VTXBaseAPI {
                 fundsRequired: true,
                 initialFundsObtained: true,
                 fundsObtained: true,
+                vtxComissionPct: true,
                 video: {
                     _id: true,
                     source: true,
                     url: true,
                     sourceData: true
                 },
+                coverImage: {
+                    _id: true,
+                    name: true,
+                    contentType: true,
+                    size: true,
+                    useType: true,
+                    url: true,
+                    key: true
+                },
                 endingDate: true,
                 competitions: {
                     _id: true,
@@ -7770,6 +7814,136 @@ class VTXBaseAPI {
         }
         return retValue;
     }
+    async browseCampaigns(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        const campaignFields = {
+            _id: true,
+            title: true,
+            slug: true,
+            motivation: true,
+            fundsRequired: true,
+            fundsObtained: true,
+            website: true,
+            status: true,
+            createdDate: true,
+            endingDate: true,
+            video: {
+                _id: true,
+                url: true,
+            },
+            location: {
+                _id: true,
+                cityNameGeocode: true,
+                stateNameGeocode: true,
+                countryIso2CodeGeocode: true,
+                city: {
+                    _id: true,
+                    name: true,
+                    state: {
+                        _id: true,
+                        name: true,
+                        country: {
+                            _id: true,
+                            name: true,
+                        },
+                    },
+                },
+            },
+            coverImage: {
+                _id: true,
+                url: true,
+                key: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true
+            },
+            budgetMode: true,
+            budget: {
+                _id: true,
+                items: {
+                    _id: true,
+                    concept: true,
+                    quantity: true,
+                    itemCost: true,
+                    unit: true,
+                },
+            },
+            competitions: {
+                _id: true,
+                event: {
+                    _id: true,
+                    name: true,
+                },
+                budget: {
+                    _id: true,
+                    items: {
+                        _id: true,
+                        concept: true,
+                        quantity: true,
+                        itemCost: true,
+                        unit: true,
+                    },
+                },
+            },
+            athlete: {
+                _id: true,
+                firstName: true,
+                lastName: true,
+                screenName: true,
+                scores: {
+                    vtxScore: true,
+                },
+                profilePicture: {
+                    _id: true,
+                    url: true,
+                    key: true
+                },
+                mainSport: {
+                    _id: true,
+                    name: true
+                },
+                mainSportLevel: {
+                    _id: true,
+                    label: true,
+                    index: true,
+                },
+                country: {
+                    _id: true,
+                    name: true,
+                }
+            }
+        };
+        try {
+            const response = await client.query({
+                browseCampaigns: {
+                    __args: { input: dto },
+                    campaigns: campaignFields,
+                    featuredPopular: campaignFields,
+                    featuredEndingSoon: campaignFields,
+                    total: true,
+                    page: true,
+                    limit: true,
+                    hasMore: true
+                }
+            });
+            retValue = (0, response_builder_1.buildResponse)(response, 'browseCampaigns', (r) => {
+                const isResponseOk = true &&
+                    Array.isArray(response?.browseCampaigns?.campaigns) &&
+                    Array.isArray(response?.browseCampaigns?.featuredPopular) &&
+                    Array.isArray(response?.browseCampaigns?.featuredEndingSoon);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
     async updateAthleteIntegration(type) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + '/graphql',
@@ -7937,18 +8111,22 @@ class VTXBaseAPI {
         }
         return retValue;
     }
-    async forceRefreshAthleteScores(athleteIds) {
+    async forceRefreshAthleteScores(athleteIds, options) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + '/graphql',
             headers: this.headers,
         });
         let retValue = {};
+        const rebuildHistorical = options?.rebuildHistorical ?? true;
+        const historicalDays = options?.historicalDays ?? 365;
         try {
             const response = await client.mutation({
                 forceRefreshAthleteScores: {
                     __args: {
                         input: {
                             athleteIds,
+                            rebuildHistorical,
+                            historicalDays,
                         },
                     },
                     results: {
@@ -7968,6 +8146,14 @@ class VTXBaseAPI {
                             status: true,
                             message: true,
                         },
+                        diagnostics: {
+                            activitiesDeleted: true,
+                            activitiesFetched: true,
+                            activitiesDateRange: true,
+                            activityRefsSaved: true,
+                            historicalDatesProcessed: true,
+                            historicalRebuildStatus: true,
+                        },
                     },
                     successCount: true,
                     failureCount: true,
@@ -8950,6 +9136,97 @@ class VTXBaseAPI {
         }
         return retValue;
     }
+    async getDonationDatesForCalendar(campaignId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            dates: true,
+            totalDonations: true,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getDonationDatesForCalendar: {
+                    __args: {
+                        campaignId: campaignId
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getDonationDatesForCalendar Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getDonationDatesForCalendar', (r) => {
+                const isResponseOk = !!response?.getDonationDatesForCalendar &&
+                    Array.isArray(response.getDonationDatesForCalendar.dates);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getDonationDatesForCalendar err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getDonationsPaginated(query) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const donationFields = {
+            checkoutSessionId: true,
+            fundingCheckoutSessionDataId: true,
+            donationMode: true,
+            donorName: true,
+            donorEmail: true,
+            completed: true,
+            confirmed: true,
+            donationAmount: true,
+            createdDate: true,
+            completedDate: true,
+            athleteId: true,
+            athleteName: true,
+            message: true,
+        };
+        const paginationFields = {
+            currentPage: true,
+            itemsPerPage: true,
+            totalItems: true,
+            totalPages: true,
+            hasNextPage: true,
+            hasPreviousPage: true,
+        };
+        const fields = {
+            donations: donationFields,
+            pagination: paginationFields,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getDonationsPaginated: {
+                    __args: {
+                        query: query
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getDonationsPaginated Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getDonationsPaginated', (r) => {
+                const isResponseOk = !!response?.getDonationsPaginated &&
+                    Array.isArray(response.getDonationsPaginated.donations);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getDonationsPaginated err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
     async getAthleteHistoricalScores(dto) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + "/graphql",
@@ -10208,54 +10485,192 @@ class VTXBaseAPI {
         }
         return retValue;
     }
-    async updateBrand(id, dto, desiredFields) {
+    async claimOffer(offerId, athleteId) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + "/graphql",
             headers: this.headers,
         });
+        const fields = {
+            _id: true,
+            claimedAt: true,
+            code: true,
+            offer: {
+                _id: true,
+                label: true,
+                type: true,
+                dateEnd: true,
+                discountTypeData: true,
+                offerImage: {
+                    url: true
+                },
+                brand: {
+                    _id: true,
+                    name: true,
+                    website: true,
+                    affiliateLink: true,
+                    logo: {
+                        url: true
+                    }
+                }
+            }
+        };
         let retValue = {};
-        const fields = desiredFields ?? { _id: true };
-        fields._id = true;
         try {
             const response = await client.mutation({
-                updateBrand: {
+                claimOffer: {
                     __args: {
-                        id: id,
-                        input: dto
+                        offerId: offerId,
+                        athleteId: athleteId
                     },
                     ...fields
                 }
             });
-            VTXBaseAPI.Logger.debug('updateBrand Response:');
+            VTXBaseAPI.Logger.debug('claimOffer Response:');
             VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
-            retValue = (0, response_builder_1.buildResponse)(response, 'updateBrand', (r) => {
-                const isResponseOk = true && response?.updateBrand?._id;
+            retValue = (0, response_builder_1.buildResponse)(response, 'claimOffer', (r) => {
+                const isResponseOk = response?.claimOffer?._id !== undefined;
                 return isResponseOk;
             });
         }
         catch (err1) {
-            VTXBaseAPI.Logger.error('updateBrand err1:');
+            VTXBaseAPI.Logger.error('claimOffer err1:');
             VTXBaseAPI.Logger.error(err1);
             retValue = (0, response_builder_1.buildErrorResponse)(err1);
         }
         return retValue;
     }
-    async deleteBrand(id) {
+    async getMyOfferClaims(args) {
         const client = (0, client_1.createClient)({
             url: this.backendUrl + "/graphql",
             headers: this.headers,
         });
-        let retValue = {};
-        try {
-            const response = await client.mutation({
-                deleteBrand: {
-                    __args: {
-                        id: id
-                    }
-                }
-            });
-            VTXBaseAPI.Logger.debug('deleteBrand Response:');
-            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+        const fields = {
+            _id: true,
+            claimedAt: true,
+            code: true,
+            offer: {
+                _id: true,
+                label: true,
+                type: true,
+                dateEnd: true,
+                discountTypeData: true,
+                offerImage: {
+                    url: true
+                },
+                brand: {
+                    _id: true,
+                    name: true,
+                    website: true,
+                    affiliateLink: true,
+                    logo: {
+                        url: true
+                    }
+                }
+            }
+        };
+        let retValue = {};
+        try {
+            const response = await client.query({
+                myOfferClaims: {
+                    __args: {
+                        athleteId: args.athleteId,
+                        query: args.query
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getMyOfferClaims Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'myOfferClaims', (r) => {
+                const isResponseOk = Array.isArray(response?.myOfferClaims);
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getMyOfferClaims err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async removeOfferClaim(claimId, athleteId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                removeOfferClaim: {
+                    __args: {
+                        claimId: claimId,
+                        athleteId: athleteId
+                    },
+                    __scalar: true
+                }
+            });
+            VTXBaseAPI.Logger.debug('removeOfferClaim Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'removeOfferClaim', (r) => {
+                const isResponseOk = response?.removeOfferClaim === true;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('removeOfferClaim err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async updateBrand(id, dto, desiredFields) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = desiredFields ?? { _id: true };
+        fields._id = true;
+        try {
+            const response = await client.mutation({
+                updateBrand: {
+                    __args: {
+                        id: id,
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('updateBrand Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'updateBrand', (r) => {
+                const isResponseOk = true && response?.updateBrand?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('updateBrand err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async deleteBrand(id) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                deleteBrand: {
+                    __args: {
+                        id: id
+                    }
+                }
+            });
+            VTXBaseAPI.Logger.debug('deleteBrand Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
             retValue = (0, response_builder_1.buildResponse)(response, 'deleteBrand', (r) => {
                 const isResponseOk = response?.deleteBrand === true;
                 return isResponseOk;
@@ -10523,6 +10938,7 @@ class VTXBaseAPI {
                 profilePicture: true,
                 score: true,
                 countryCode: true,
+                nationalityCode: true,
                 cityName: true,
                 countryRank: true,
                 sportId: true,
@@ -10868,6 +11284,8 @@ class VTXBaseAPI {
             activityCount: true,
             avgScorePerActivity: true,
             topMetrics: topMetricFields,
+            newMaxActivityIds: true,
+            metricMaxes: true,
         };
         let retValue;
         try {
@@ -11046,6 +11464,950 @@ class VTXBaseAPI {
         }
         return retValue;
     }
+    async getMyNotifications(options) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const notificationFields = {
+            id: true,
+            type: true,
+            title: true,
+            message: true,
+            iconType: true,
+            iconUrl: true,
+            actionRoute: true,
+            actionParams: true,
+            actionLabel: true,
+            read: true,
+            dismissed: true,
+            createdAt: true,
+        };
+        const fields = {
+            notifications: notificationFields,
+            total: true,
+            hasMore: true,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                myNotifications: {
+                    __args: { input: options || {} },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getMyNotifications Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'myNotifications', (r) => {
+                const isResponseOk = response?.myNotifications?.notifications !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getMyNotifications err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getNotificationUnreadCount() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            count: true,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                notificationUnreadCount: {
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getNotificationUnreadCount Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'notificationUnreadCount', (r) => {
+                const isResponseOk = response?.notificationUnreadCount?.count !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getNotificationUnreadCount err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getMyNotificationPreferences() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            id: true,
+            emailEnabled: true,
+            inAppEnabled: true,
+            pushEnabled: true,
+            mutedTypes: true,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                myNotificationPreferences: {
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getMyNotificationPreferences Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'myNotificationPreferences', (r) => {
+                const isResponseOk = response?.myNotificationPreferences?.id !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getMyNotificationPreferences err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async markNotificationAsRead(notificationId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            id: true,
+            read: true,
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                markNotificationAsRead: {
+                    __args: { input: { notificationId } },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('markNotificationAsRead Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'markNotificationAsRead', (r) => {
+                const isResponseOk = response?.markNotificationAsRead?.id !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('markNotificationAsRead err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async markAllNotificationsAsRead() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue;
+        try {
+            const response = await client.mutation({
+                markAllNotificationsAsRead: true
+            });
+            VTXBaseAPI.Logger.debug('markAllNotificationsAsRead Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'markAllNotificationsAsRead', (r) => {
+                const isResponseOk = response?.markAllNotificationsAsRead !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('markAllNotificationsAsRead err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async dismissNotification(notificationId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue;
+        try {
+            const response = await client.mutation({
+                dismissNotification: {
+                    __args: { input: { notificationId } },
+                }
+            });
+            VTXBaseAPI.Logger.debug('dismissNotification Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'dismissNotification', (r) => {
+                const isResponseOk = response?.dismissNotification !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('dismissNotification err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerDeviceToken(token, platform, deviceName) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            id: true,
+            userId: true,
+            token: true,
+            platform: true,
+            deviceName: true,
+            active: true,
+        };
+        let retValue;
+        try {
+            const input = { token, platform, deviceName };
+            const response = await client.mutation({
+                registerDeviceToken: {
+                    __args: { input },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('registerDeviceToken Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerDeviceToken', (r) => {
+                const isResponseOk = response?.registerDeviceToken?.id !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('registerDeviceToken err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async unregisterDeviceToken(token) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue;
+        try {
+            const input = { token };
+            const response = await client.mutation({
+                unregisterDeviceToken: {
+                    __args: { input },
+                }
+            });
+            VTXBaseAPI.Logger.debug('unregisterDeviceToken Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'unregisterDeviceToken', (r) => {
+                const isResponseOk = response?.unregisterDeviceToken !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('unregisterDeviceToken err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async updateNotificationPreferences(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            id: true,
+            emailEnabled: true,
+            inAppEnabled: true,
+            pushEnabled: true,
+            mutedTypes: true,
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                updateNotificationPreferences: {
+                    __args: { input },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('updateNotificationPreferences Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'updateNotificationPreferences', (r) => {
+                const isResponseOk = response?.updateNotificationPreferences?.id !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('updateNotificationPreferences err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async followAthlete(athleteId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue;
+        try {
+            const response = await client.mutation({
+                followAthlete: {
+                    __args: { input: { athleteId } },
+                }
+            });
+            VTXBaseAPI.Logger.debug('followAthlete Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'followAthlete', (r) => {
+                const isResponseOk = response?.followAthlete !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('followAthlete err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async unfollowAthlete(athleteId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue;
+        try {
+            const response = await client.mutation({
+                unfollowAthlete: {
+                    __args: { input: { athleteId } },
+                }
+            });
+            VTXBaseAPI.Logger.debug('unfollowAthlete Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'unfollowAthlete', (r) => {
+                const isResponseOk = response?.unfollowAthlete !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('unfollowAthlete err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async isFollowingAthlete(athleteId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            isFollowing: true,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                isFollowingAthlete: {
+                    __args: { input: { athleteId } },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('isFollowingAthlete Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'isFollowingAthlete', (r) => {
+                const isResponseOk = response?.isFollowingAthlete?.isFollowing !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('isFollowingAthlete err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getMyFollowedAthletes(options) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const athleteFields = {
+            id: true,
+            firstName: true,
+            lastName: true,
+            screenName: true,
+            profilePicture: {
+                _id: true,
+                url: true,
+                key: true,
+            },
+            sportName: true,
+            vtxScore: true,
+        };
+        const fields = {
+            athletes: athleteFields,
+            total: true,
+            hasMore: true,
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                myFollowedAthletes: {
+                    __args: { input: options || null },
+                    ...fields
+                }
+            });
+            VTXBaseAPI.Logger.debug('getMyFollowedAthletes Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'myFollowedAthletes', (r) => {
+                const isResponseOk = response?.myFollowedAthletes?.athletes !== undefined;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getMyFollowedAthletes err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async deleteOnboardingAthlete() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                deleteOnboardingAthlete: {
+                    success: true,
+                    athleteId: true,
+                    error: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('deleteOnboardingAthlete Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'deleteOnboardingAthlete', (r) => response?.deleteOnboardingAthlete?.success === true);
+        }
+        catch (err) {
+            VTXBaseAPI.Logger.error('deleteOnboardingAthlete error:');
+            VTXBaseAPI.Logger.error(err);
+            retValue = (0, response_builder_1.buildErrorResponse)(err);
+        }
+        return retValue;
+    }
+    async updateOnboardingProgress(step, complete) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                updateOnboardingProgress: {
+                    __args: { input: { step, complete } },
+                    success: true,
+                    step: true,
+                    complete: true,
+                    error: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('updateOnboardingProgress Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'updateOnboardingProgress', (r) => response?.updateOnboardingProgress?.success === true);
+        }
+        catch (err) {
+            VTXBaseAPI.Logger.error('updateOnboardingProgress error:');
+            VTXBaseAPI.Logger.error(err);
+            retValue = (0, response_builder_1.buildErrorResponse)(err);
+        }
+        return retValue;
+    }
+    async getOnboardingProgress() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.query({
+                getOnboardingProgress: {
+                    success: true,
+                    step: true,
+                    complete: true,
+                    athleteId: true,
+                    error: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('getOnboardingProgress Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getOnboardingProgress', (r) => response?.getOnboardingProgress?.success === true);
+        }
+        catch (err) {
+            VTXBaseAPI.Logger.error('getOnboardingProgress error:');
+            VTXBaseAPI.Logger.error(err);
+            retValue = (0, response_builder_1.buildErrorResponse)(err);
+        }
+        return retValue;
+    }
+    async getPublicAthleteIntegrationStatus(athleteId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.query({
+                getPublicAthleteIntegrationStatus: {
+                    __args: { athleteId },
+                    hasStravaIntegration: true,
+                    stravaAthleteId: true,
+                    hasInstagramIntegration: true,
+                    instagramUsername: true,
+                },
+            });
+            retValue = (0, response_builder_1.buildResponse)(response, 'getPublicAthleteIntegrationStatus', (r) => response?.getPublicAthleteIntegrationStatus != null);
+        }
+        catch (err) {
+            retValue = (0, response_builder_1.buildErrorResponse)(err);
+        }
+        return retValue;
+    }
+    async getEmailCampaigns(args) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.query({
+                getEmailCampaigns: {
+                    __args: { ...args },
+                    campaigns: {
+                        _id: true,
+                        subject: true,
+                        templateId: true,
+                        templateName: true,
+                        htmlContent: true,
+                        audienceFilters: true,
+                        segmentId: true,
+                        status: true,
+                        scheduledFor: true,
+                        sentAt: true,
+                        recipientCount: true,
+                        createdBy: true,
+                        createdAt: true,
+                        updatedAt: true,
+                        testSentAt: true,
+                        deliveryStats: {
+                            delivered: true,
+                            opens: true,
+                            uniqueOpens: true,
+                            clicks: true,
+                            uniqueClicks: true,
+                            bounces: true,
+                            spamReports: true,
+                            lastUpdated: true,
+                        },
+                        segment: {
+                            _id: true,
+                            name: true,
+                            filters: true,
+                            createdBy: true,
+                            createdAt: true,
+                        },
+                    },
+                    total: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('getEmailCampaigns Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getEmailCampaigns', (r) => response?.getEmailCampaigns?.campaigns != null);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getEmailCampaigns err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createEmailCampaign(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                createEmailCampaign: {
+                    __args: { input },
+                    _id: true,
+                    subject: true,
+                    status: true,
+                    createdAt: true,
+                    updatedAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('createEmailCampaign Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createEmailCampaign', (r) => response?.createEmailCampaign?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createEmailCampaign err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async updateEmailCampaign(id, input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                updateEmailCampaign: {
+                    __args: { id, input },
+                    _id: true,
+                    subject: true,
+                    status: true,
+                    updatedAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('updateEmailCampaign Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'updateEmailCampaign', (r) => response?.updateEmailCampaign?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('updateEmailCampaign err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async deleteEmailCampaign(id) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                deleteEmailCampaign: {
+                    __args: { id },
+                    __scalar: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('deleteEmailCampaign Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'deleteEmailCampaign', (r) => response?.deleteEmailCampaign === true);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('deleteEmailCampaign err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async cloneEmailCampaign(id) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                cloneEmailCampaign: {
+                    __args: { id },
+                    _id: true,
+                    subject: true,
+                    status: true,
+                    createdAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('cloneEmailCampaign Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'cloneEmailCampaign', (r) => response?.cloneEmailCampaign?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('cloneEmailCampaign err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async sendTestEmail(campaignId, email) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                sendTestEmail: {
+                    __args: { campaignId, adminEmail: email },
+                    _id: true,
+                    testSentAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('sendTestEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'sendTestEmail', (r) => response?.sendTestEmail?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('sendTestEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async sendBulkEmail(campaignId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                sendBulkEmail: {
+                    __args: { campaignId },
+                    _id: true,
+                    status: true,
+                    sentAt: true,
+                    recipientCount: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('sendBulkEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'sendBulkEmail', (r) => response?.sendBulkEmail?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('sendBulkEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async scheduleEmailCampaign(campaignId, scheduledFor) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                scheduleEmailCampaign: {
+                    __args: { campaignId, scheduledFor },
+                    _id: true,
+                    status: true,
+                    scheduledFor: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('scheduleEmailCampaign Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'scheduleEmailCampaign', (r) => response?.scheduleEmailCampaign?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('scheduleEmailCampaign err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async cancelScheduledEmail(campaignId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                cancelScheduledEmail: {
+                    __args: { campaignId },
+                    _id: true,
+                    status: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('cancelScheduledEmail Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'cancelScheduledEmail', (r) => response?.cancelScheduledEmail?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('cancelScheduledEmail err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getAudiencePreview(filters) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.query({
+                getAudiencePreview: {
+                    __args: { filters },
+                    total: true,
+                    users: {
+                        _id: true,
+                        name: true,
+                        email: true,
+                        type: true,
+                    },
+                },
+            });
+            VTXBaseAPI.Logger.debug('getAudiencePreview Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getAudiencePreview', (r) => response?.getAudiencePreview?.total != null);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getAudiencePreview err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getSendGridTemplates() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.query({
+                getSendGridTemplates: {
+                    id: true,
+                    name: true,
+                    updatedAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('getSendGridTemplates Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getSendGridTemplates', (r) => response?.getSendGridTemplates != null);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getSendGridTemplates err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getEmailSegments() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.query({
+                getEmailSegments: {
+                    _id: true,
+                    name: true,
+                    filters: true,
+                    createdBy: true,
+                    createdAt: true,
+                    updatedAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('getEmailSegments Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getEmailSegments', (r) => response?.getEmailSegments != null);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('getEmailSegments err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async createEmailSegment(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                createEmailSegment: {
+                    __args: { input },
+                    _id: true,
+                    name: true,
+                    filters: true,
+                    createdBy: true,
+                    createdAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('createEmailSegment Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'createEmailSegment', (r) => response?.createEmailSegment?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('createEmailSegment err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async updateEmailSegment(id, input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                updateEmailSegment: {
+                    __args: { id, input },
+                    _id: true,
+                    name: true,
+                    filters: true,
+                    updatedAt: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('updateEmailSegment Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'updateEmailSegment', (r) => response?.updateEmailSegment?._id);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('updateEmailSegment err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async deleteEmailSegment(id) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                deleteEmailSegment: {
+                    __args: { id },
+                    __scalar: true,
+                },
+            });
+            VTXBaseAPI.Logger.debug('deleteEmailSegment Response:');
+            VTXBaseAPI.Logger.debug(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'deleteEmailSegment', (r) => response?.deleteEmailSegment === true);
+        }
+        catch (err1) {
+            VTXBaseAPI.Logger.error('deleteEmailSegment err1:');
+            VTXBaseAPI.Logger.error(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
 }
 exports.VTXBaseAPI = VTXBaseAPI;
 VTXBaseAPI.Logger = {