@easyedu/js-lsm-api 1.116.0 → 1.118.0

package/dist/esm/apis/IntegrationApi.js

@@ -21,27 +21,71 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
+import { CustomWebhookIntegrationFromJSON, } from '../models/CustomWebhookIntegration';
 import { GetZapierCoursesFromJSON, } from '../models/GetZapierCourses';
 import { GetZapierMeFromJSON, } from '../models/GetZapierMe';
 import { GetZapierSetupFromJSON, } from '../models/GetZapierSetup';
 import { GetZapierShopifyCourseMappingsFromJSON, } from '../models/GetZapierShopifyCourseMappings';
 import { GetZapierUsersFromJSON, } from '../models/GetZapierUsers';
+import { IntegrationEventFromJSON, } from '../models/IntegrationEvent';
+import { PostCustomWebhookIntegrationToJSON, } from '../models/PostCustomWebhookIntegration';
 import { PostZapierEnrollmentToJSON, } from '../models/PostZapierEnrollment';
 import { PostZapierSetupToJSON, } from '../models/PostZapierSetup';
 import { PostZapierSetupResponseFromJSON, } from '../models/PostZapierSetupResponse';
 import { PostZapierShopifyCourseMappingToJSON, } from '../models/PostZapierShopifyCourseMapping';
 import { PostZapierShopifyEnrollmentToJSON, } from '../models/PostZapierShopifyEnrollment';
 import { PostZapierShopifyEnrollmentResponseFromJSON, } from '../models/PostZapierShopifyEnrollmentResponse';
+import { PostZapierSubscriptionToJSON, } from '../models/PostZapierSubscription';
 import { PostZapierUserToJSON, } from '../models/PostZapierUser';
+import { PutCustomWebhookIntegrationToJSON, } from '../models/PutCustomWebhookIntegration';
 import { PutZapierSetupToJSON, } from '../models/PutZapierSetup';
 import { ZapierEnrollmentFromJSON, } from '../models/ZapierEnrollment';
 import { ZapierIntegrationFromJSON, } from '../models/ZapierIntegration';
 import { ZapierShopifyCourseMappingFromJSON, } from '../models/ZapierShopifyCourseMapping';
+import { ZapierSubscriptionFromJSON, } from '../models/ZapierSubscription';
 import { ZapierUserFromJSON, } from '../models/ZapierUser';
 /**
  *
  */
 export class IntegrationApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for deleteCustomWebhookIntegration without sending the request
+     */
+    deleteCustomWebhookIntegrationRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['webhookIntegrationId'] == null) {
+                throw new runtime.RequiredError('webhookIntegrationId', 'Required parameter "webhookIntegrationId" was null or undefined when calling deleteCustomWebhookIntegration().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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
+     */
+    deleteCustomWebhookIntegrationRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteCustomWebhookIntegrationRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Delete a custom webhook destination
+     */
+    deleteCustomWebhookIntegration(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteCustomWebhookIntegrationRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Creates request options for deleteZapierSetup without sending the request
      */
@@ -80,6 +124,91 @@ export class IntegrationApi extends runtime.BaseAPI {
             yield this.deleteZapierSetupRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Creates request options for deleteZapierSubscription without sending the request
+     */
+    deleteZapierSubscriptionRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 deleteZapierSubscription().');
+            }
+            if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+                throw new runtime.RequiredError('xPORTALSUBDOMAIN', 'Required parameter "xPORTALSUBDOMAIN" was null or undefined when calling deleteZapierSubscription().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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/{subscriptionId}`;
+            urlPath = urlPath.replace('{subscriptionId}', encodeURIComponent(String(requestParameters['subscriptionId'])));
+            return {
+                path: urlPath,
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Unsubscribe a Zap from an Edaxu lifecycle event
+     */
+    deleteZapierSubscriptionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteZapierSubscriptionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Unsubscribe a Zap from an Edaxu lifecycle event
+     */
+    deleteZapierSubscription(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteZapierSubscriptionRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for getCustomWebhookIntegrations without sending the request
+     */
+    getCustomWebhookIntegrationsRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/integrations/webhooks`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List custom webhook destinations for the selected portal
+     */
+    getCustomWebhookIntegrationsRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCustomWebhookIntegrationsRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CustomWebhookIntegrationFromJSON));
+        });
+    }
+    /**
+     * List custom webhook destinations for the selected portal
+     */
+    getCustomWebhookIntegrations(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCustomWebhookIntegrationsRaw(initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getZapierCourses without sending the request
      */
@@ -136,6 +265,62 @@ export class IntegrationApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getZapierEvents without sending the request
+     */
+    getZapierEventsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['xAPIKEY'] == null) {
+                throw new runtime.RequiredError('xAPIKEY', 'Required parameter "xAPIKEY" was null or undefined when calling getZapierEvents().');
+            }
+            if (requestParameters['xPORTALSUBDOMAIN'] == null) {
+                throw new runtime.RequiredError('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 = {};
+            if (requestParameters['eventType'] != null) {
+                queryParameters['eventType'] = requestParameters['eventType'];
+            }
+            if (requestParameters['pageSize'] != null) {
+                queryParameters['pageSize'] = requestParameters['pageSize'];
+            }
+            const headerParameters = {};
+            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/events`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List recent lifecycle events for Zapier trigger setup
+     */
+    getZapierEventsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getZapierEventsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(IntegrationEventFromJSON));
+        });
+    }
+    /**
+     * List recent lifecycle events for Zapier trigger setup
+     */
+    getZapierEvents(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getZapierEventsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getZapierMe without sending the request
      */
@@ -321,6 +506,46 @@ export class IntegrationApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for postCustomWebhookIntegration without sending the request
+     */
+    postCustomWebhookIntegrationRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postCustomWebhookIntegration'] == null) {
+                throw new runtime.RequiredError('postCustomWebhookIntegration', 'Required parameter "postCustomWebhookIntegration" was null or undefined when calling postCustomWebhookIntegration().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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
+     */
+    postCustomWebhookIntegrationRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCustomWebhookIntegrationRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CustomWebhookIntegrationFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a custom webhook destination for lifecycle events
+     */
+    postCustomWebhookIntegration(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCustomWebhookIntegrationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for postZapierEnrollment without sending the request
      */
@@ -517,6 +742,58 @@ export class IntegrationApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for postZapierSubscription without sending the request
+     */
+    postZapierSubscriptionRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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
+     */
+    postZapierSubscriptionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postZapierSubscriptionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ZapierSubscriptionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Subscribe a Zap to an Edaxu lifecycle event
+     */
+    postZapierSubscription(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postZapierSubscriptionRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for postZapierUser without sending the request
      */
@@ -569,6 +846,50 @@ export class IntegrationApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for putCustomWebhookIntegration without sending the request
+     */
+    putCustomWebhookIntegrationRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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
+     */
+    putCustomWebhookIntegrationRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putCustomWebhookIntegrationRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CustomWebhookIntegrationFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update a custom webhook destination
+     */
+    putCustomWebhookIntegration(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putCustomWebhookIntegrationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for putZapierSetup without sending the request
      */
@@ -614,3 +935,13 @@ export class IntegrationApi extends runtime.BaseAPI {
         });
     }
 }
+/**
+ * @export
+ */
+export const GetZapierEventsEventTypeEnum = {
+    ComEdaxuEnrollmentEnrolledV1: 'com.edaxu.enrollment.enrolled.v1',
+    ComEdaxuEnrollmentCompletedV1: 'com.edaxu.enrollment.completed.v1',
+    ComEdaxuCertificateIssuedV1: 'com.edaxu.certificate.issued.v1',
+    ComEdaxuPortalUserInvitedV1: 'com.edaxu.portal.user_invited.v1',
+    ComEdaxuPortalUserJoinedV1: 'com.edaxu.portal.user_joined.v1'
+};

package/dist/esm/models/CustomWebhookIntegration.d.ts

@@ -0,0 +1,85 @@
+/**
+ * LMS API
+ * LMS API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface CustomWebhookIntegration
+ */
+export interface CustomWebhookIntegration {
+    /**
+     *
+     * @type {string}
+     * @memberof CustomWebhookIntegration
+     */
+    id: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CustomWebhookIntegration
+     */
+    name: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CustomWebhookIntegration
+     */
+    targetUrl: string;
+    /**
+     *
+     * @type {Set<CustomWebhookIntegrationEventTypesEnum>}
+     * @memberof CustomWebhookIntegration
+     */
+    eventTypes: Set<CustomWebhookIntegrationEventTypesEnum>;
+    /**
+     *
+     * @type {boolean}
+     * @memberof CustomWebhookIntegration
+     */
+    enabled: boolean;
+    /**
+     * True when an encrypted bearer token is configured. The token is never returned.
+     * @type {boolean}
+     * @memberof CustomWebhookIntegration
+     */
+    tokenConfigured: boolean;
+    /**
+     *
+     * @type {Date}
+     * @memberof CustomWebhookIntegration
+     */
+    createdAt: Date;
+    /**
+     *
+     * @type {Date}
+     * @memberof CustomWebhookIntegration
+     */
+    updatedAt: Date;
+}
+/**
+ * @export
+ */
+export declare const CustomWebhookIntegrationEventTypesEnum: {
+    readonly ComEdaxuEnrollmentEnrolledV1: "com.edaxu.enrollment.enrolled.v1";
+    readonly ComEdaxuEnrollmentCompletedV1: "com.edaxu.enrollment.completed.v1";
+    readonly ComEdaxuCertificateIssuedV1: "com.edaxu.certificate.issued.v1";
+    readonly ComEdaxuPortalUserInvitedV1: "com.edaxu.portal.user_invited.v1";
+    readonly ComEdaxuPortalUserJoinedV1: "com.edaxu.portal.user_joined.v1";
+};
+export type CustomWebhookIntegrationEventTypesEnum = typeof CustomWebhookIntegrationEventTypesEnum[keyof typeof CustomWebhookIntegrationEventTypesEnum];
+/**
+ * Check if a given object implements the CustomWebhookIntegration interface.
+ */
+export declare function instanceOfCustomWebhookIntegration(value: object): value is CustomWebhookIntegration;
+export declare function CustomWebhookIntegrationFromJSON(json: any): CustomWebhookIntegration;
+export declare function CustomWebhookIntegrationFromJSONTyped(json: any, ignoreDiscriminator: boolean): CustomWebhookIntegration;
+export declare function CustomWebhookIntegrationToJSON(json: any): CustomWebhookIntegration;
+export declare function CustomWebhookIntegrationToJSONTyped(value?: CustomWebhookIntegration | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/CustomWebhookIntegration.js

@@ -0,0 +1,81 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * LMS API
+ * LMS API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * @export
+ */
+export const CustomWebhookIntegrationEventTypesEnum = {
+    ComEdaxuEnrollmentEnrolledV1: 'com.edaxu.enrollment.enrolled.v1',
+    ComEdaxuEnrollmentCompletedV1: 'com.edaxu.enrollment.completed.v1',
+    ComEdaxuCertificateIssuedV1: 'com.edaxu.certificate.issued.v1',
+    ComEdaxuPortalUserInvitedV1: 'com.edaxu.portal.user_invited.v1',
+    ComEdaxuPortalUserJoinedV1: 'com.edaxu.portal.user_joined.v1'
+};
+/**
+ * Check if a given object implements the CustomWebhookIntegration interface.
+ */
+export function instanceOfCustomWebhookIntegration(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('name' in value) || value['name'] === undefined)
+        return false;
+    if (!('targetUrl' in value) || value['targetUrl'] === undefined)
+        return false;
+    if (!('eventTypes' in value) || value['eventTypes'] === undefined)
+        return false;
+    if (!('enabled' in value) || value['enabled'] === undefined)
+        return false;
+    if (!('tokenConfigured' in value) || value['tokenConfigured'] === undefined)
+        return false;
+    if (!('createdAt' in value) || value['createdAt'] === undefined)
+        return false;
+    if (!('updatedAt' in value) || value['updatedAt'] === undefined)
+        return false;
+    return true;
+}
+export function CustomWebhookIntegrationFromJSON(json) {
+    return CustomWebhookIntegrationFromJSONTyped(json, false);
+}
+export function CustomWebhookIntegrationFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'name': json['name'],
+        'targetUrl': json['target_url'],
+        'eventTypes': new Set(json['event_types']),
+        'enabled': json['enabled'],
+        'tokenConfigured': json['token_configured'],
+        'createdAt': (new Date(json['created_at'])),
+        'updatedAt': (new Date(json['updated_at'])),
+    };
+}
+export function CustomWebhookIntegrationToJSON(json) {
+    return CustomWebhookIntegrationToJSONTyped(json, false);
+}
+export function CustomWebhookIntegrationToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'name': value['name'],
+        'target_url': value['targetUrl'],
+        'event_types': Array.from(value['eventTypes']),
+        'enabled': value['enabled'],
+        'token_configured': value['tokenConfigured'],
+        'created_at': value['createdAt'].toISOString(),
+        'updated_at': value['updatedAt'].toISOString(),
+    };
+}

package/dist/esm/models/IntegrationEvent.d.ts

@@ -0,0 +1,100 @@
+/**
+ * LMS API
+ * LMS API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { IntegrationEventData } from './IntegrationEventData';
+/**
+ * A CloudEvents 1.0 structured JSON event emitted by Edaxu.
+ * @export
+ * @interface IntegrationEvent
+ */
+export interface IntegrationEvent {
+    /**
+     *
+     * @type {IntegrationEventSpecversionEnum}
+     * @memberof IntegrationEvent
+     */
+    specversion: IntegrationEventSpecversionEnum;
+    /**
+     *
+     * @type {string}
+     * @memberof IntegrationEvent
+     */
+    id: string;
+    /**
+     * Stable URI identifying the portal event source.
+     * @type {string}
+     * @memberof IntegrationEvent
+     */
+    source: string;
+    /**
+     *
+     * @type {IntegrationEventTypeEnum}
+     * @memberof IntegrationEvent
+     */
+    type: IntegrationEventTypeEnum;
+    /**
+     *
+     * @type {Date}
+     * @memberof IntegrationEvent
+     */
+    time: Date;
+    /**
+     *
+     * @type {string}
+     * @memberof IntegrationEvent
+     */
+    subject: string;
+    /**
+     *
+     * @type {IntegrationEventDatacontenttypeEnum}
+     * @memberof IntegrationEvent
+     */
+    datacontenttype: IntegrationEventDatacontenttypeEnum;
+    /**
+     *
+     * @type {IntegrationEventData}
+     * @memberof IntegrationEvent
+     */
+    data: IntegrationEventData;
+}
+/**
+ * @export
+ */
+export declare const IntegrationEventSpecversionEnum: {
+    readonly _10: "1.0";
+};
+export type IntegrationEventSpecversionEnum = typeof IntegrationEventSpecversionEnum[keyof typeof IntegrationEventSpecversionEnum];
+/**
+ * @export
+ */
+export declare const IntegrationEventTypeEnum: {
+    readonly ComEdaxuEnrollmentEnrolledV1: "com.edaxu.enrollment.enrolled.v1";
+    readonly ComEdaxuEnrollmentCompletedV1: "com.edaxu.enrollment.completed.v1";
+    readonly ComEdaxuCertificateIssuedV1: "com.edaxu.certificate.issued.v1";
+    readonly ComEdaxuPortalUserInvitedV1: "com.edaxu.portal.user_invited.v1";
+    readonly ComEdaxuPortalUserJoinedV1: "com.edaxu.portal.user_joined.v1";
+};
+export type IntegrationEventTypeEnum = typeof IntegrationEventTypeEnum[keyof typeof IntegrationEventTypeEnum];
+/**
+ * @export
+ */
+export declare const IntegrationEventDatacontenttypeEnum: {
+    readonly ApplicationJson: "application/json";
+};
+export type IntegrationEventDatacontenttypeEnum = typeof IntegrationEventDatacontenttypeEnum[keyof typeof IntegrationEventDatacontenttypeEnum];
+/**
+ * Check if a given object implements the IntegrationEvent interface.
+ */
+export declare function instanceOfIntegrationEvent(value: object): value is IntegrationEvent;
+export declare function IntegrationEventFromJSON(json: any): IntegrationEvent;
+export declare function IntegrationEventFromJSONTyped(json: any, ignoreDiscriminator: boolean): IntegrationEvent;
+export declare function IntegrationEventToJSON(json: any): IntegrationEvent;
+export declare function IntegrationEventToJSONTyped(value?: IntegrationEvent | null, ignoreDiscriminator?: boolean): any;