@easyedu/js-lsm-api 1.115.0 → 1.117.0

package/src/apis/IntegrationApi.ts

@@ -13,6 +13,16 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type CustomWebhookIntegration,
+    CustomWebhookIntegrationFromJSON,
+    CustomWebhookIntegrationToJSON,
+} from '../models/CustomWebhookIntegration';
+import {
+    type GetZapierCourses,
+    GetZapierCoursesFromJSON,
+    GetZapierCoursesToJSON,
+} from '../models/GetZapierCourses';
 import {
     type GetZapierMe,
     GetZapierMeFromJSON,
@@ -23,6 +33,31 @@ import {
     GetZapierSetupFromJSON,
     GetZapierSetupToJSON,
 } from '../models/GetZapierSetup';
+import {
+    type GetZapierShopifyCourseMappings,
+    GetZapierShopifyCourseMappingsFromJSON,
+    GetZapierShopifyCourseMappingsToJSON,
+} from '../models/GetZapierShopifyCourseMappings';
+import {
+    type GetZapierUsers,
+    GetZapierUsersFromJSON,
+    GetZapierUsersToJSON,
+} from '../models/GetZapierUsers';
+import {
+    type IntegrationEvent,
+    IntegrationEventFromJSON,
+    IntegrationEventToJSON,
+} from '../models/IntegrationEvent';
+import {
+    type PostCustomWebhookIntegration,
+    PostCustomWebhookIntegrationFromJSON,
+    PostCustomWebhookIntegrationToJSON,
+} from '../models/PostCustomWebhookIntegration';
+import {
+    type PostZapierEnrollment,
+    PostZapierEnrollmentFromJSON,
+    PostZapierEnrollmentToJSON,
+} from '../models/PostZapierEnrollment';
 import {
     type PostZapierSetup,
     PostZapierSetupFromJSON,
@@ -33,30 +68,156 @@ import {
     PostZapierSetupResponseFromJSON,
     PostZapierSetupResponseToJSON,
 } from '../models/PostZapierSetupResponse';
+import {
+    type PostZapierShopifyCourseMapping,
+    PostZapierShopifyCourseMappingFromJSON,
+    PostZapierShopifyCourseMappingToJSON,
+} from '../models/PostZapierShopifyCourseMapping';
+import {
+    type PostZapierShopifyEnrollment,
+    PostZapierShopifyEnrollmentFromJSON,
+    PostZapierShopifyEnrollmentToJSON,
+} from '../models/PostZapierShopifyEnrollment';
+import {
+    type PostZapierShopifyEnrollmentResponse,
+    PostZapierShopifyEnrollmentResponseFromJSON,
+    PostZapierShopifyEnrollmentResponseToJSON,
+} from '../models/PostZapierShopifyEnrollmentResponse';
+import {
+    type PostZapierSubscription,
+    PostZapierSubscriptionFromJSON,
+    PostZapierSubscriptionToJSON,
+} from '../models/PostZapierSubscription';
+import {
+    type PostZapierUser,
+    PostZapierUserFromJSON,
+    PostZapierUserToJSON,
+} from '../models/PostZapierUser';
+import {
+    type PutCustomWebhookIntegration,
+    PutCustomWebhookIntegrationFromJSON,
+    PutCustomWebhookIntegrationToJSON,
+} from '../models/PutCustomWebhookIntegration';
 import {
     type PutZapierSetup,
     PutZapierSetupFromJSON,
     PutZapierSetupToJSON,
 } from '../models/PutZapierSetup';
+import {
+    type ZapierEnrollment,
+    ZapierEnrollmentFromJSON,
+    ZapierEnrollmentToJSON,
+} from '../models/ZapierEnrollment';
 import {
     type ZapierIntegration,
     ZapierIntegrationFromJSON,
     ZapierIntegrationToJSON,
 } from '../models/ZapierIntegration';
+import {
+    type ZapierShopifyCourseMapping,
+    ZapierShopifyCourseMappingFromJSON,
+    ZapierShopifyCourseMappingToJSON,
+} from '../models/ZapierShopifyCourseMapping';
+import {
+    type ZapierSubscription,
+    ZapierSubscriptionFromJSON,
+    ZapierSubscriptionToJSON,
+} from '../models/ZapierSubscription';
+import {
+    type ZapierUser,
+    ZapierUserFromJSON,
+    ZapierUserToJSON,
+} from '../models/ZapierUser';
+
+export interface DeleteCustomWebhookIntegrationRequest {
+    webhookIntegrationId: string;
+}
 
 export interface DeleteZapierSetupRequest {
     zapierIntegrationId: string;
 }
 
+export interface DeleteZapierSubscriptionRequest {
+    subscriptionId: string;
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+}
+
+export interface GetZapierCoursesRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetZapierEventsRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    eventType: GetZapierEventsEventTypeEnum;
+    pageSize?: number;
+}
+
 export interface GetZapierMeRequest {
     xAPIKEY: string;
     xPORTALSUBDOMAIN: string;
 }
 
+export interface GetZapierShopifyCourseMappingsRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    shopDomain?: string;
+}
+
+export interface GetZapierUsersRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    email: string;
+}
+
+export interface PostCustomWebhookIntegrationRequest {
+    postCustomWebhookIntegration: PostCustomWebhookIntegration;
+}
+
+export interface PostZapierEnrollmentRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    postZapierEnrollment: PostZapierEnrollment;
+}
+
 export interface PostZapierSetupRequest {
     postZapierSetup: PostZapierSetup;
 }
 
+export interface PostZapierShopifyCourseMappingRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    postZapierShopifyCourseMapping: PostZapierShopifyCourseMapping;
+}
+
+export interface PostZapierShopifyEnrollmentRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    postZapierShopifyEnrollment: PostZapierShopifyEnrollment;
+}
+
+export interface PostZapierSubscriptionRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    postZapierSubscription: PostZapierSubscription;
+}
+
+export interface PostZapierUserRequest {
+    xAPIKEY: string;
+    xPORTALSUBDOMAIN: string;
+    postZapierUser: PostZapierUser;
+}
+
+export interface PutCustomWebhookIntegrationRequest {
+    webhookIntegrationId: string;
+    putCustomWebhookIntegration: PutCustomWebhookIntegration;
+}
+
 export interface PutZapierSetupRequest {
     zapierIntegrationId: string;
     putZapierSetup: PutZapierSetup;
@@ -67,6 +228,50 @@ export interface PutZapierSetupRequest {
  */
 export class IntegrationApi extends runtime.BaseAPI {
 
+    /**
+     * Creates request options for deleteCustomWebhookIntegration without sending the request
+     */
+    async deleteCustomWebhookIntegrationRequestOpts(requestParameters: DeleteCustomWebhookIntegrationRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['webhookIntegrationId'] == null) {
+            throw new runtime.RequiredError(
+                'webhookIntegrationId',
+                'Required parameter "webhookIntegrationId" was null or undefined when calling deleteCustomWebhookIntegration().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/integrations/webhooks/{webhookIntegrationId}`;
+        urlPath = urlPath.replace('{webhookIntegrationId}', encodeURIComponent(String(requestParameters['webhookIntegrationId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete a custom webhook destination
+     */
+    async deleteCustomWebhookIntegrationRaw(requestParameters: DeleteCustomWebhookIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteCustomWebhookIntegrationRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete a custom webhook destination
+     */
+    async deleteCustomWebhookIntegration(requestParameters: DeleteCustomWebhookIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteCustomWebhookIntegrationRaw(requestParameters, initOverrides);
+    }
+
     /**
      * Creates request options for deleteZapierSetup without sending the request
      */
@@ -112,20 +317,27 @@ export class IntegrationApi extends runtime.BaseAPI {
     }
 
     /**
-     * Creates request options for getZapierMe without sending the request
+     * Creates request options for deleteZapierSubscription without sending the request
      */
-    async getZapierMeRequestOpts(requestParameters: GetZapierMeRequest): Promise<runtime.RequestOpts> {
+    async deleteZapierSubscriptionRequestOpts(requestParameters: DeleteZapierSubscriptionRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['subscriptionId'] == null) {
+            throw new runtime.RequiredError(
+                'subscriptionId',
+                'Required parameter "subscriptionId" was null or undefined when calling deleteZapierSubscription().'
+            );
+        }
+
         if (requestParameters['xAPIKEY'] == null) {
             throw new runtime.RequiredError(
                 'xAPIKEY',
-                'Required parameter "xAPIKEY" was null or undefined when calling getZapierMe().'
+                'Required parameter "xAPIKEY" was null or undefined when calling deleteZapierSubscription().'
             );
         }
 
         if (requestParameters['xPORTALSUBDOMAIN'] == null) {
             throw new runtime.RequiredError(
                 'xPORTALSUBDOMAIN',
-                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling getZapierMe().'
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling deleteZapierSubscription().'
             );
         }
 
@@ -142,44 +354,44 @@ export class IntegrationApi extends runtime.BaseAPI {
         }
 
 
-        let urlPath = `/integrations/zapier/me`;
+        let urlPath = `/integrations/zapier/subscriptions/{subscriptionId}`;
+        urlPath = urlPath.replace('{subscriptionId}', encodeURIComponent(String(requestParameters['subscriptionId'])));
 
         return {
             path: urlPath,
-            method: 'GET',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         };
     }
 
     /**
-     * Test a Zapier API key and return its portal and enabled permissions
+     * Unsubscribe a Zap from an Edaxu lifecycle event
      */
-    async getZapierMeRaw(requestParameters: GetZapierMeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierMe>> {
-        const requestOptions = await this.getZapierMeRequestOpts(requestParameters);
+    async deleteZapierSubscriptionRaw(requestParameters: DeleteZapierSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteZapierSubscriptionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierMeFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Test a Zapier API key and return its portal and enabled permissions
+     * Unsubscribe a Zap from an Edaxu lifecycle event
      */
-    async getZapierMe(requestParameters: GetZapierMeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierMe> {
-        const response = await this.getZapierMeRaw(requestParameters, initOverrides);
-        return await response.value();
+    async deleteZapierSubscription(requestParameters: DeleteZapierSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteZapierSubscriptionRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Creates request options for getZapierSetup without sending the request
+     * Creates request options for getCustomWebhookIntegrations without sending the request
      */
-    async getZapierSetupRequestOpts(): Promise<runtime.RequestOpts> {
+    async getCustomWebhookIntegrationsRequestOpts(): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
 
-        let urlPath = `/integrations/zapier/setup`;
+        let urlPath = `/integrations/webhooks`;
 
         return {
             path: urlPath,
@@ -190,123 +402,954 @@ export class IntegrationApi extends runtime.BaseAPI {
     }
 
     /**
-     * List Zapier connections and permissions available to the selected portal
+     * List custom webhook destinations for the selected portal
      */
-    async getZapierSetupRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierSetup>> {
-        const requestOptions = await this.getZapierSetupRequestOpts();
+    async getCustomWebhookIntegrationsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CustomWebhookIntegration>>> {
+        const requestOptions = await this.getCustomWebhookIntegrationsRequestOpts();
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierSetupFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CustomWebhookIntegrationFromJSON));
     }
 
     /**
-     * List Zapier connections and permissions available to the selected portal
+     * List custom webhook destinations for the selected portal
      */
-    async getZapierSetup(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierSetup> {
-        const response = await this.getZapierSetupRaw(initOverrides);
+    async getCustomWebhookIntegrations(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CustomWebhookIntegration>> {
+        const response = await this.getCustomWebhookIntegrationsRaw(initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for postZapierSetup without sending the request
+     * Creates request options for getZapierCourses without sending the request
      */
-    async postZapierSetupRequestOpts(requestParameters: PostZapierSetupRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['postZapierSetup'] == null) {
+    async getZapierCoursesRequestOpts(requestParameters: GetZapierCoursesRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
             throw new runtime.RequiredError(
-                'postZapierSetup',
-                'Required parameter "postZapierSetup" was null or undefined when calling postZapierSetup().'
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling getZapierCourses().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling getZapierCourses().'
             );
         }
 
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
 
 
-        let urlPath = `/integrations/zapier/setup`;
+        let urlPath = `/integrations/zapier/courses`;
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PostZapierSetupToJSON(requestParameters['postZapierSetup']),
         };
     }
 
     /**
-     * Create a Zapier connection and API key for the selected portal
+     * List published courses available to a Zapier connection
      */
-    async postZapierSetupRaw(requestParameters: PostZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostZapierSetupResponse>> {
-        const requestOptions = await this.postZapierSetupRequestOpts(requestParameters);
+    async getZapierCoursesRaw(requestParameters: GetZapierCoursesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierCourses>> {
+        const requestOptions = await this.getZapierCoursesRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => PostZapierSetupResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierCoursesFromJSON(jsonValue));
     }
 
     /**
-     * Create a Zapier connection and API key for the selected portal
+     * List published courses available to a Zapier connection
      */
-    async postZapierSetup(requestParameters: PostZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PostZapierSetupResponse> {
-        const response = await this.postZapierSetupRaw(requestParameters, initOverrides);
+    async getZapierCourses(requestParameters: GetZapierCoursesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierCourses> {
+        const response = await this.getZapierCoursesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for putZapierSetup without sending the request
+     * Creates request options for getZapierEvents without sending the request
      */
-    async putZapierSetupRequestOpts(requestParameters: PutZapierSetupRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['zapierIntegrationId'] == null) {
+    async getZapierEventsRequestOpts(requestParameters: GetZapierEventsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
             throw new runtime.RequiredError(
-                'zapierIntegrationId',
-                'Required parameter "zapierIntegrationId" was null or undefined when calling putZapierSetup().'
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling getZapierEvents().'
             );
         }
 
-        if (requestParameters['putZapierSetup'] == null) {
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
             throw new runtime.RequiredError(
-                'putZapierSetup',
-                'Required parameter "putZapierSetup" was null or undefined when calling putZapierSetup().'
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling getZapierEvents().'
+            );
+        }
+
+        if (requestParameters['eventType'] == null) {
+            throw new runtime.RequiredError(
+                'eventType',
+                'Required parameter "eventType" was null or undefined when calling getZapierEvents().'
             );
         }
 
         const queryParameters: any = {};
 
+        if (requestParameters['eventType'] != null) {
+            queryParameters['eventType'] = requestParameters['eventType'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
 
 
-        let urlPath = `/integrations/zapier/setup/{zapierIntegrationId}`;
-        urlPath = urlPath.replace('{zapierIntegrationId}', encodeURIComponent(String(requestParameters['zapierIntegrationId'])));
+        let urlPath = `/integrations/zapier/events`;
 
         return {
             path: urlPath,
-            method: 'PUT',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PutZapierSetupToJSON(requestParameters['putZapierSetup']),
         };
     }
 
     /**
-     * Update a Zapier connection\'s name or permissions
+     * List recent lifecycle events for Zapier trigger setup
      */
-    async putZapierSetupRaw(requestParameters: PutZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ZapierIntegration>> {
-        const requestOptions = await this.putZapierSetupRequestOpts(requestParameters);
+    async getZapierEventsRaw(requestParameters: GetZapierEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<IntegrationEvent>>> {
+        const requestOptions = await this.getZapierEventsRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ZapierIntegrationFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(IntegrationEventFromJSON));
     }
 
     /**
-     * Update a Zapier connection\'s name or permissions
+     * List recent lifecycle events for Zapier trigger setup
      */
-    async putZapierSetup(requestParameters: PutZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ZapierIntegration> {
-        const response = await this.putZapierSetupRaw(requestParameters, initOverrides);
+    async getZapierEvents(requestParameters: GetZapierEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<IntegrationEvent>> {
+        const response = await this.getZapierEventsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
-}
+    /**
+     * Creates request options for getZapierMe without sending the request
+     */
+    async getZapierMeRequestOpts(requestParameters: GetZapierMeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling getZapierMe().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling getZapierMe().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/me`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Test a Zapier API key and return its portal and enabled permissions
+     */
+    async getZapierMeRaw(requestParameters: GetZapierMeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierMe>> {
+        const requestOptions = await this.getZapierMeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierMeFromJSON(jsonValue));
+    }
+
+    /**
+     * Test a Zapier API key and return its portal and enabled permissions
+     */
+    async getZapierMe(requestParameters: GetZapierMeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierMe> {
+        const response = await this.getZapierMeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getZapierSetup without sending the request
+     */
+    async getZapierSetupRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/integrations/zapier/setup`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * List Zapier connections and permissions available to the selected portal
+     */
+    async getZapierSetupRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierSetup>> {
+        const requestOptions = await this.getZapierSetupRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierSetupFromJSON(jsonValue));
+    }
+
+    /**
+     * List Zapier connections and permissions available to the selected portal
+     */
+    async getZapierSetup(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierSetup> {
+        const response = await this.getZapierSetupRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getZapierShopifyCourseMappings without sending the request
+     */
+    async getZapierShopifyCourseMappingsRequestOpts(requestParameters: GetZapierShopifyCourseMappingsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling getZapierShopifyCourseMappings().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling getZapierShopifyCourseMappings().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['shopDomain'] != null) {
+            queryParameters['shopDomain'] = requestParameters['shopDomain'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/shopify/course-mappings`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * List Shopify variant-to-course mappings
+     */
+    async getZapierShopifyCourseMappingsRaw(requestParameters: GetZapierShopifyCourseMappingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierShopifyCourseMappings>> {
+        const requestOptions = await this.getZapierShopifyCourseMappingsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierShopifyCourseMappingsFromJSON(jsonValue));
+    }
+
+    /**
+     * List Shopify variant-to-course mappings
+     */
+    async getZapierShopifyCourseMappings(requestParameters: GetZapierShopifyCourseMappingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierShopifyCourseMappings> {
+        const response = await this.getZapierShopifyCourseMappingsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getZapierUsers without sending the request
+     */
+    async getZapierUsersRequestOpts(requestParameters: GetZapierUsersRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling getZapierUsers().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling getZapierUsers().'
+            );
+        }
+
+        if (requestParameters['email'] == null) {
+            throw new runtime.RequiredError(
+                'email',
+                'Required parameter "email" was null or undefined when calling getZapierUsers().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['email'] != null) {
+            queryParameters['email'] = requestParameters['email'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/users`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Find a learner by exact email address
+     */
+    async getZapierUsersRaw(requestParameters: GetZapierUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetZapierUsers>> {
+        const requestOptions = await this.getZapierUsersRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetZapierUsersFromJSON(jsonValue));
+    }
+
+    /**
+     * Find a learner by exact email address
+     */
+    async getZapierUsers(requestParameters: GetZapierUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetZapierUsers> {
+        const response = await this.getZapierUsersRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCustomWebhookIntegration without sending the request
+     */
+    async postCustomWebhookIntegrationRequestOpts(requestParameters: PostCustomWebhookIntegrationRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['postCustomWebhookIntegration'] == null) {
+            throw new runtime.RequiredError(
+                'postCustomWebhookIntegration',
+                'Required parameter "postCustomWebhookIntegration" was null or undefined when calling postCustomWebhookIntegration().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/integrations/webhooks`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCustomWebhookIntegrationToJSON(requestParameters['postCustomWebhookIntegration']),
+        };
+    }
+
+    /**
+     * Create a custom webhook destination for lifecycle events
+     */
+    async postCustomWebhookIntegrationRaw(requestParameters: PostCustomWebhookIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CustomWebhookIntegration>> {
+        const requestOptions = await this.postCustomWebhookIntegrationRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CustomWebhookIntegrationFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a custom webhook destination for lifecycle events
+     */
+    async postCustomWebhookIntegration(requestParameters: PostCustomWebhookIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CustomWebhookIntegration> {
+        const response = await this.postCustomWebhookIntegrationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postZapierEnrollment without sending the request
+     */
+    async postZapierEnrollmentRequestOpts(requestParameters: PostZapierEnrollmentRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling postZapierEnrollment().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling postZapierEnrollment().'
+            );
+        }
+
+        if (requestParameters['postZapierEnrollment'] == null) {
+            throw new runtime.RequiredError(
+                'postZapierEnrollment',
+                'Required parameter "postZapierEnrollment" was null or undefined when calling postZapierEnrollment().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/enrollments`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostZapierEnrollmentToJSON(requestParameters['postZapierEnrollment']),
+        };
+    }
+
+    /**
+     * Enroll an existing learner in a course
+     */
+    async postZapierEnrollmentRaw(requestParameters: PostZapierEnrollmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ZapierEnrollment>> {
+        const requestOptions = await this.postZapierEnrollmentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ZapierEnrollmentFromJSON(jsonValue));
+    }
+
+    /**
+     * Enroll an existing learner in a course
+     */
+    async postZapierEnrollment(requestParameters: PostZapierEnrollmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ZapierEnrollment> {
+        const response = await this.postZapierEnrollmentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postZapierSetup without sending the request
+     */
+    async postZapierSetupRequestOpts(requestParameters: PostZapierSetupRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['postZapierSetup'] == null) {
+            throw new runtime.RequiredError(
+                'postZapierSetup',
+                'Required parameter "postZapierSetup" was null or undefined when calling postZapierSetup().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/integrations/zapier/setup`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostZapierSetupToJSON(requestParameters['postZapierSetup']),
+        };
+    }
+
+    /**
+     * Create a Zapier connection and API key for the selected portal
+     */
+    async postZapierSetupRaw(requestParameters: PostZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostZapierSetupResponse>> {
+        const requestOptions = await this.postZapierSetupRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PostZapierSetupResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a Zapier connection and API key for the selected portal
+     */
+    async postZapierSetup(requestParameters: PostZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PostZapierSetupResponse> {
+        const response = await this.postZapierSetupRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postZapierShopifyCourseMapping without sending the request
+     */
+    async postZapierShopifyCourseMappingRequestOpts(requestParameters: PostZapierShopifyCourseMappingRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling postZapierShopifyCourseMapping().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling postZapierShopifyCourseMapping().'
+            );
+        }
+
+        if (requestParameters['postZapierShopifyCourseMapping'] == null) {
+            throw new runtime.RequiredError(
+                'postZapierShopifyCourseMapping',
+                'Required parameter "postZapierShopifyCourseMapping" was null or undefined when calling postZapierShopifyCourseMapping().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/shopify/course-mappings`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostZapierShopifyCourseMappingToJSON(requestParameters['postZapierShopifyCourseMapping']),
+        };
+    }
+
+    /**
+     * Create or update a Shopify variant-to-course mapping
+     */
+    async postZapierShopifyCourseMappingRaw(requestParameters: PostZapierShopifyCourseMappingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ZapierShopifyCourseMapping>> {
+        const requestOptions = await this.postZapierShopifyCourseMappingRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ZapierShopifyCourseMappingFromJSON(jsonValue));
+    }
+
+    /**
+     * Create or update a Shopify variant-to-course mapping
+     */
+    async postZapierShopifyCourseMapping(requestParameters: PostZapierShopifyCourseMappingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ZapierShopifyCourseMapping> {
+        const response = await this.postZapierShopifyCourseMappingRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postZapierShopifyEnrollment without sending the request
+     */
+    async postZapierShopifyEnrollmentRequestOpts(requestParameters: PostZapierShopifyEnrollmentRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling postZapierShopifyEnrollment().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling postZapierShopifyEnrollment().'
+            );
+        }
+
+        if (requestParameters['postZapierShopifyEnrollment'] == null) {
+            throw new runtime.RequiredError(
+                'postZapierShopifyEnrollment',
+                'Required parameter "postZapierShopifyEnrollment" was null or undefined when calling postZapierShopifyEnrollment().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/shopify/enrollments`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostZapierShopifyEnrollmentToJSON(requestParameters['postZapierShopifyEnrollment']),
+        };
+    }
+
+    /**
+     * Find or invite a Shopify customer and enroll them using the purchased variant mapping
+     */
+    async postZapierShopifyEnrollmentRaw(requestParameters: PostZapierShopifyEnrollmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostZapierShopifyEnrollmentResponse>> {
+        const requestOptions = await this.postZapierShopifyEnrollmentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PostZapierShopifyEnrollmentResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Find or invite a Shopify customer and enroll them using the purchased variant mapping
+     */
+    async postZapierShopifyEnrollment(requestParameters: PostZapierShopifyEnrollmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PostZapierShopifyEnrollmentResponse> {
+        const response = await this.postZapierShopifyEnrollmentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postZapierSubscription without sending the request
+     */
+    async postZapierSubscriptionRequestOpts(requestParameters: PostZapierSubscriptionRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling postZapierSubscription().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling postZapierSubscription().'
+            );
+        }
+
+        if (requestParameters['postZapierSubscription'] == null) {
+            throw new runtime.RequiredError(
+                'postZapierSubscription',
+                'Required parameter "postZapierSubscription" was null or undefined when calling postZapierSubscription().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/subscriptions`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostZapierSubscriptionToJSON(requestParameters['postZapierSubscription']),
+        };
+    }
+
+    /**
+     * Subscribe a Zap to an Edaxu lifecycle event
+     */
+    async postZapierSubscriptionRaw(requestParameters: PostZapierSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ZapierSubscription>> {
+        const requestOptions = await this.postZapierSubscriptionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ZapierSubscriptionFromJSON(jsonValue));
+    }
+
+    /**
+     * Subscribe a Zap to an Edaxu lifecycle event
+     */
+    async postZapierSubscription(requestParameters: PostZapierSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ZapierSubscription> {
+        const response = await this.postZapierSubscriptionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postZapierUser without sending the request
+     */
+    async postZapierUserRequestOpts(requestParameters: PostZapierUserRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['xAPIKEY'] == null) {
+            throw new runtime.RequiredError(
+                'xAPIKEY',
+                'Required parameter "xAPIKEY" was null or undefined when calling postZapierUser().'
+            );
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+            throw new runtime.RequiredError(
+                'xPORTALSUBDOMAIN',
+                'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling postZapierUser().'
+            );
+        }
+
+        if (requestParameters['postZapierUser'] == null) {
+            throw new runtime.RequiredError(
+                'postZapierUser',
+                'Required parameter "postZapierUser" was null or undefined when calling postZapierUser().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xAPIKEY'] != null) {
+            headerParameters['X-API-KEY'] = String(requestParameters['xAPIKEY']);
+        }
+
+        if (requestParameters['xPORTALSUBDOMAIN'] != null) {
+            headerParameters['X-PORTAL-SUBDOMAIN'] = String(requestParameters['xPORTALSUBDOMAIN']);
+        }
+
+
+        let urlPath = `/integrations/zapier/users`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostZapierUserToJSON(requestParameters['postZapierUser']),
+        };
+    }
+
+    /**
+     * Find or invite a learner to the connected portal
+     */
+    async postZapierUserRaw(requestParameters: PostZapierUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ZapierUser>> {
+        const requestOptions = await this.postZapierUserRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ZapierUserFromJSON(jsonValue));
+    }
+
+    /**
+     * Find or invite a learner to the connected portal
+     */
+    async postZapierUser(requestParameters: PostZapierUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ZapierUser> {
+        const response = await this.postZapierUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for putCustomWebhookIntegration without sending the request
+     */
+    async putCustomWebhookIntegrationRequestOpts(requestParameters: PutCustomWebhookIntegrationRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['webhookIntegrationId'] == null) {
+            throw new runtime.RequiredError(
+                'webhookIntegrationId',
+                'Required parameter "webhookIntegrationId" was null or undefined when calling putCustomWebhookIntegration().'
+            );
+        }
+
+        if (requestParameters['putCustomWebhookIntegration'] == null) {
+            throw new runtime.RequiredError(
+                'putCustomWebhookIntegration',
+                'Required parameter "putCustomWebhookIntegration" was null or undefined when calling putCustomWebhookIntegration().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/integrations/webhooks/{webhookIntegrationId}`;
+        urlPath = urlPath.replace('{webhookIntegrationId}', encodeURIComponent(String(requestParameters['webhookIntegrationId'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PutCustomWebhookIntegrationToJSON(requestParameters['putCustomWebhookIntegration']),
+        };
+    }
+
+    /**
+     * Update a custom webhook destination
+     */
+    async putCustomWebhookIntegrationRaw(requestParameters: PutCustomWebhookIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CustomWebhookIntegration>> {
+        const requestOptions = await this.putCustomWebhookIntegrationRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CustomWebhookIntegrationFromJSON(jsonValue));
+    }
+
+    /**
+     * Update a custom webhook destination
+     */
+    async putCustomWebhookIntegration(requestParameters: PutCustomWebhookIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CustomWebhookIntegration> {
+        const response = await this.putCustomWebhookIntegrationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for putZapierSetup without sending the request
+     */
+    async putZapierSetupRequestOpts(requestParameters: PutZapierSetupRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['zapierIntegrationId'] == null) {
+            throw new runtime.RequiredError(
+                'zapierIntegrationId',
+                'Required parameter "zapierIntegrationId" was null or undefined when calling putZapierSetup().'
+            );
+        }
+
+        if (requestParameters['putZapierSetup'] == null) {
+            throw new runtime.RequiredError(
+                'putZapierSetup',
+                'Required parameter "putZapierSetup" was null or undefined when calling putZapierSetup().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/integrations/zapier/setup/{zapierIntegrationId}`;
+        urlPath = urlPath.replace('{zapierIntegrationId}', encodeURIComponent(String(requestParameters['zapierIntegrationId'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PutZapierSetupToJSON(requestParameters['putZapierSetup']),
+        };
+    }
+
+    /**
+     * Update a Zapier connection\'s name or permissions
+     */
+    async putZapierSetupRaw(requestParameters: PutZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ZapierIntegration>> {
+        const requestOptions = await this.putZapierSetupRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ZapierIntegrationFromJSON(jsonValue));
+    }
+
+    /**
+     * Update a Zapier connection\'s name or permissions
+     */
+    async putZapierSetup(requestParameters: PutZapierSetupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ZapierIntegration> {
+        const response = await this.putZapierSetupRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+}
+
+/**
+ * @export
+ */
+export const GetZapierEventsEventTypeEnum = {
+    ComEdaxuEnrollmentEnrolledV1: 'com.edaxu.enrollment.enrolled.v1',
+    ComEdaxuEnrollmentCompletedV1: 'com.edaxu.enrollment.completed.v1',
+    ComEdaxuCertificateIssuedV1: 'com.edaxu.certificate.issued.v1'
+} as const;
+export type GetZapierEventsEventTypeEnum = typeof GetZapierEventsEventTypeEnum[keyof typeof GetZapierEventsEventTypeEnum];