@iblai/iblai-api 0.0.1-core

package/src/services/NotificationBuilderService.ts

@@ -0,0 +1,133 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ContextResponse } from '../models/ContextResponse';
+import type { NotificationPreview } from '../models/NotificationPreview';
+import type { NotificationSource } from '../models/NotificationSource';
+import type { PreviewResponse } from '../models/PreviewResponse';
+import type { Recipient } from '../models/Recipient';
+import type { SendNotification } from '../models/SendNotification';
+import type { SendResponse } from '../models/SendResponse';
+import type { ValidateSourceResponse } from '../models/ValidateSourceResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class NotificationBuilderService {
+    /**
+     * Get build recipients
+     * Get paginated list of recipients for a notification build
+     * @param id
+     * @param platformKey
+     * @param page Page number
+     * @param pageSize Number of items per page
+     * @param search Search recipients by username or email
+     * @returns Recipient
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationBuilderRecipientsList(
+        id: string,
+        platformKey: string,
+        page?: number,
+        pageSize?: number,
+        search?: string,
+    ): CancelablePromise<Array<Recipient>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/notification/v1/orgs/{platform_key}/notification-builder/{id}/recipients/',
+            path: {
+                'id': id,
+                'platform_key': platformKey,
+            },
+            query: {
+                'page': page,
+                'page_size': pageSize,
+                'search': search,
+            },
+        });
+    }
+    /**
+     * Get notification context data
+     * Get all context data needed for notification building including templates, channels, and platforms
+     * @param platformKey
+     * @returns ContextResponse
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationBuilderContextRetrieve(
+        platformKey: string,
+    ): CancelablePromise<ContextResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/notification/v1/orgs/{platform_key}/notification-builder/context/',
+            path: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Preview notification
+     * Preview notification recipients and get build ID for sending
+     * @param platformKey
+     * @param requestBody
+     * @returns PreviewResponse
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationBuilderPreviewCreate(
+        platformKey: string,
+        requestBody: NotificationPreview,
+    ): CancelablePromise<PreviewResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/notification/v1/orgs/{platform_key}/notification-builder/preview/',
+            path: {
+                'platform_key': platformKey,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Send notification
+     * Send notifications to all recipients in a build
+     * @param platformKey
+     * @param requestBody
+     * @returns SendResponse
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationBuilderSendCreate(
+        platformKey: string,
+        requestBody: SendNotification,
+    ): CancelablePromise<SendResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/notification/v1/orgs/{platform_key}/notification-builder/send/',
+            path: {
+                'platform_key': platformKey,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Validate notification source
+     * Validate a single notification source (email, username, platform, csv)
+     * @param platformKey
+     * @param requestBody
+     * @returns ValidateSourceResponse
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationBuilderValidateSourceCreate(
+        platformKey: string,
+        requestBody: NotificationSource,
+    ): CancelablePromise<ValidateSourceResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/notification/v1/orgs/{platform_key}/notification-builder/validate_source/',
+            path: {
+                'platform_key': platformKey,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}

package/src/services/NotificationService.ts

@@ -0,0 +1,317 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CampaignEnablement } from '../models/CampaignEnablement';
+import type { CampaignExclusion } from '../models/CampaignExclusion';
+import type { MarkAllReadRequest } from '../models/MarkAllReadRequest';
+import type { MarkAllReadResponse } from '../models/MarkAllReadResponse';
+import type { Notification } from '../models/Notification';
+import type { NotificationCount } from '../models/NotificationCount';
+import type { PatchedNotification } from '../models/PatchedNotification';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class NotificationService {
+    /**
+     * Unsubscribe from a campaign using a hash
+     * @param unsubscribeHash
+     * @returns any
+     * @throws ApiError
+     */
+    public static notificationV1CampaignsUnsubscribeRetrieve(
+        unsubscribeHash: string,
+    ): CancelablePromise<{
+        success?: boolean;
+        message?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/notification/v1/campaigns/unsubscribe/{unsubscribe_hash}/',
+            path: {
+                'unsubscribe_hash': unsubscribeHash,
+            },
+        });
+    }
+    /**
+     * Get notifications for a user
+     * @param org
+     * @param channel
+     * @param endDate
+     * @param excludeChannel
+     * @param startDate
+     * @param status
+     * @returns Notification
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationsRetrieve(
+        org: string,
+        channel?: string,
+        endDate?: string,
+        excludeChannel?: string,
+        startDate?: string,
+        status?: string,
+    ): CancelablePromise<Notification> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/notification/v1/orgs/{org}/notifications/',
+            path: {
+                'org': org,
+            },
+            query: {
+                'channel': channel,
+                'end_date': endDate,
+                'exclude_channel': excludeChannel,
+                'start_date': startDate,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param requestBody
+     * @returns Notification
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationsUpdate(
+        org: string,
+        requestBody: Notification,
+    ): CancelablePromise<Notification> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/notification/v1/orgs/{org}/notifications/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param requestBody
+     * @returns Notification
+     * @throws ApiError
+     */
+    public static notificationV1OrgsNotificationsBulkUpdatePartialUpdate(
+        org: string,
+        requestBody?: PatchedNotification,
+    ): CancelablePromise<Notification> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/notification/v1/orgs/{org}/notifications/bulk-update/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get notifications for a user
+     * @param org
+     * @param userId
+     * @param channel
+     * @param endDate
+     * @param excludeChannel
+     * @param startDate
+     * @param status
+     * @returns Notification
+     * @throws ApiError
+     */
+    public static notificationV1OrgsUsersNotificationsRetrieve(
+        org: string,
+        userId: string,
+        channel?: string,
+        endDate?: string,
+        excludeChannel?: string,
+        startDate?: string,
+        status?: string,
+    ): CancelablePromise<Notification> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/notification/v1/orgs/{org}/users/{user_id}/notifications/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'channel': channel,
+                'end_date': endDate,
+                'exclude_channel': excludeChannel,
+                'start_date': startDate,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param userId
+     * @param requestBody
+     * @returns Notification
+     * @throws ApiError
+     */
+    public static notificationV1OrgsUsersNotificationsUpdate(
+        org: string,
+        userId: string,
+        requestBody: Notification,
+    ): CancelablePromise<Notification> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/notification/v1/orgs/{org}/users/{user_id}/notifications/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get notifications count for a user
+     * @param org
+     * @param userId
+     * @param channel
+     * @param status
+     * @returns NotificationCount
+     * @throws ApiError
+     */
+    public static notificationV1OrgsUsersNotificationsCountRetrieve(
+        org: string,
+        userId: string,
+        channel?: string,
+        status?: string,
+    ): CancelablePromise<NotificationCount> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/notification/v1/orgs/{org}/users/{user_id}/notifications-count/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'channel': channel,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param notificationId
+     * @param org
+     * @param userId
+     * @returns void
+     * @throws ApiError
+     */
+    public static notificationV1OrgsUsersNotificationsDestroy(
+        notificationId: string,
+        org: string,
+        userId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/notification/v1/orgs/{org}/users/{user_id}/notifications/{notification_id}/',
+            path: {
+                'notification_id': notificationId,
+                'org': org,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param userId
+     * @param requestBody
+     * @returns Notification
+     * @throws ApiError
+     */
+    public static notificationV1OrgsUsersNotificationsBulkUpdatePartialUpdate(
+        org: string,
+        userId: string,
+        requestBody?: PatchedNotification,
+    ): CancelablePromise<Notification> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/notification/v1/orgs/{org}/users/{user_id}/notifications/bulk-update/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Re-enable campaigns for a user
+     * @param platformKey
+     * @param requestBody
+     * @returns any
+     * @throws ApiError
+     */
+    public static notificationV1OrgsCampaignsEnableCreate(
+        platformKey: string,
+        requestBody?: CampaignEnablement,
+    ): CancelablePromise<{
+        success?: boolean;
+        message?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/notification/v1/orgs/{platform_key}/campaigns/enable/',
+            path: {
+                'platform_key': platformKey,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Exclude a user from specified campaigns
+     * @param platformKey
+     * @param requestBody
+     * @returns any
+     * @throws ApiError
+     */
+    public static notificationV1OrgsCampaignsExcludeCreate(
+        platformKey: string,
+        requestBody?: CampaignExclusion,
+    ): CancelablePromise<{
+        success?: boolean;
+        message?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/notification/v1/orgs/{platform_key}/campaigns/exclude/',
+            path: {
+                'platform_key': platformKey,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Mark all notifications as read for a user. Optionally provide specific notification IDs.
+     * @param platformKey
+     * @param requestBody
+     * @returns MarkAllReadResponse
+     * @throws ApiError
+     */
+    public static notificationV1OrgsMarkAllAsReadCreate(
+        platformKey: string,
+        requestBody?: MarkAllReadRequest,
+    ): CancelablePromise<MarkAllReadResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/notification/v1/orgs/{platform_key}/mark-all-as-read',
+            path: {
+                'platform_key': platformKey,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}