@cognigy/rest-api-client 0.9.1 → 0.12.0

package/build/apigroups/SessionsAPIGroup_2_0.js

@@ -11,27 +11,28 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionsAPIGroup_2_0 = void 0;
 const GenericAPIFn_1 = require("../GenericAPIFn");
 function SessionsAPIGroup_2_0(instance) {
     const self = instance;
     return {
-        inject: (args) => (GenericAPIFn_1.GenericAPIFn("/new/v2.0/endpoint/inject", "POST", self))(args),
-        notify: (args) => (GenericAPIFn_1.GenericAPIFn("/new/v2.0/endpoint/notify", "POST", self))(args),
-        injectContext: (_a) => {
+        inject: (args, options) => (GenericAPIFn_1.GenericAPIFn("/new/v2.0/endpoint/inject", "POST", self))(args, options),
+        notify: (args, options) => (GenericAPIFn_1.GenericAPIFn("/new/v2.0/endpoint/notify", "POST", self))(args, options),
+        injectContext: (_a, options) => {
             var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
-            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/context/inject`, "POST", self))(args);
+            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/context/inject`, "POST", self))(args, options);
         },
-        resetContext: (_a) => {
+        resetContext: (_a, options) => {
             var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
-            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/context/reset`, "POST", self))(args);
+            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/context/reset`, "POST", self))(args, options);
         },
-        injectState: (_a) => {
+        injectState: (_a, options) => {
             var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
-            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/state/inject`, "POST", self))(args);
+            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/state/inject`, "POST", self))(args, options);
         },
-        resetState: (_a) => {
+        resetState: (_a, options) => {
             var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
-            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/state/reset`, "POST", self))(args);
+            return (GenericAPIFn_1.GenericAPIFn(`/new/v2.0/sessions/${sessionId}/state/reset`, "POST", self))(args, options);
         },
     };
 }

package/build/apigroups/TRestAPIGroupsTypeByConfiguration.js

@@ -1,4 +1,3 @@
 "use strict";
-/* Interfaces */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=TRestAPIGroupsTypeByConfiguration.js.map

package/build/apigroups/TRestAPIOperation.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TRestAPIOperation.js.map

package/build/apigroups/index.js

@@ -1,15 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsAPIGroup_2_0 = exports.SessionsAPIGroup_2_0 = exports.ResourcesAPIGroup_2_0 = exports.ManagementAPIGroup_2_0 = exports.MetricsAPIGroup_2_0 = exports.InsightsAPIGroup_2_0 = exports.ExternalAPIGroup_2_0 = exports.AdministrationAPIGroup_2_0 = void 0;
 var AdministrationAPIGroup_2_0_1 = require("./AdministrationAPIGroup_2_0");
-exports.AdministrationAPIGroup_2_0 = AdministrationAPIGroup_2_0_1.AdministrationAPIGroup_2_0;
+Object.defineProperty(exports, "AdministrationAPIGroup_2_0", { enumerable: true, get: function () { return AdministrationAPIGroup_2_0_1.AdministrationAPIGroup_2_0; } });
 var ExternalAPIGroup_2_0_1 = require("./ExternalAPIGroup_2_0");
-exports.ExternalAPIGroup_2_0 = ExternalAPIGroup_2_0_1.ExternalAPIGroup_2_0;
-var HandoverAPIGroup_2_0_1 = require("./HandoverAPIGroup_2_0");
-exports.HandoverAPIGroup_2_0 = HandoverAPIGroup_2_0_1.HandoverAPIGroup_2_0;
+Object.defineProperty(exports, "ExternalAPIGroup_2_0", { enumerable: true, get: function () { return ExternalAPIGroup_2_0_1.ExternalAPIGroup_2_0; } });
+var InsightsAPIGroup_2_0_1 = require("./InsightsAPIGroup_2_0");
+Object.defineProperty(exports, "InsightsAPIGroup_2_0", { enumerable: true, get: function () { return InsightsAPIGroup_2_0_1.InsightsAPIGroup_2_0; } });
 var MetricsAPIGroup_2_0_1 = require("./MetricsAPIGroup_2_0");
-exports.MetricsAPIGroup_2_0 = MetricsAPIGroup_2_0_1.MetricsAPIGroup_2_0;
+Object.defineProperty(exports, "MetricsAPIGroup_2_0", { enumerable: true, get: function () { return MetricsAPIGroup_2_0_1.MetricsAPIGroup_2_0; } });
+var ManagementAPIGroup_2_0_1 = require("./ManagementAPIGroup_2_0");
+Object.defineProperty(exports, "ManagementAPIGroup_2_0", { enumerable: true, get: function () { return ManagementAPIGroup_2_0_1.ManagementAPIGroup_2_0; } });
 var ResourcesAPIGroup_2_0_1 = require("./ResourcesAPIGroup_2_0");
-exports.ResourcesAPIGroup_2_0 = ResourcesAPIGroup_2_0_1.ResourcesAPIGroup_2_0;
+Object.defineProperty(exports, "ResourcesAPIGroup_2_0", { enumerable: true, get: function () { return ResourcesAPIGroup_2_0_1.ResourcesAPIGroup_2_0; } });
 var SessionsAPIGroup_2_0_1 = require("./SessionsAPIGroup_2_0");
-exports.SessionsAPIGroup_2_0 = SessionsAPIGroup_2_0_1.SessionsAPIGroup_2_0;
+Object.defineProperty(exports, "SessionsAPIGroup_2_0", { enumerable: true, get: function () { return SessionsAPIGroup_2_0_1.SessionsAPIGroup_2_0; } });
+var AnalyticsAPIGroup_2_0_1 = require("./AnalyticsAPIGroup_2_0");
+Object.defineProperty(exports, "AnalyticsAPIGroup_2_0", { enumerable: true, get: function () { return AnalyticsAPIGroup_2_0_1.AnalyticsAPIGroup_2_0; } });
 //# sourceMappingURL=index.js.map

package/build/authentication/ApiKey/ApiKeyAuthentication.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyAuthentication = void 0;
+exports.ApiKeyAuthentication = function (credentials, self) {
+    if (!(this instanceof exports.ApiKeyAuthentication)) {
+        return new exports.ApiKeyAuthentication(credentials, self);
+    }
+    else {
+        self.credentials = {
+            apiKey: credentials.apiKey,
+            type: credentials.type,
+        };
+        const ApiKeyAuthentication = function () { };
+        ApiKeyAuthentication.prototype.getAuthenticationHeaders = async () => {
+            const headers = {};
+            headers["x-api-key"] = credentials.apiKey || "";
+            return headers;
+        };
+        return new ApiKeyAuthentication(credentials, self);
+    }
+};
+exports.default = exports.ApiKeyAuthentication;
+//# sourceMappingURL=ApiKeyAuthentication.js.map

package/build/authentication/AuthenticationAPI.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ApiKeyAuthentication_1 = require("./ApiKeyAuthentication");
-const OAuth2Authentication_1 = require("./OAuth2Authentication");
-const OAuth2InjectionAuthentication_1 = require("./OAuth2InjectionAuthentication");
+exports.AuthenticationAPI = void 0;
+const GenericAPIFn_1 = require("../GenericAPIFn");
+/* Authentication Methods */
+const ApiKeyAuthentication_1 = require("./ApiKey/ApiKeyAuthentication");
+const BasicAuthentication_1 = require("./BasicAuthentication/BasicAuthentication");
+const OAuth2Authentication_1 = require("./OAuth2/OAuth2Authentication");
+const rest_1 = require("../shared/helper/rest");
 function AuthenticationAPI(instance) {
     const self = instance;
     return {
@@ -11,13 +15,39 @@ function AuthenticationAPI(instance) {
                 case "ApiKey":
                     self.authenticationHandler = new ApiKeyAuthentication_1.ApiKeyAuthentication(credentials, self);
                     break;
+                case "Basic":
+                    self.authenticationHandler = new BasicAuthentication_1.BasicAuthentication(credentials, self);
+                    break;
                 case "OAuth2":
                     self.authenticationHandler = new OAuth2Authentication_1.OAuth2Authentication(credentials, self);
                     break;
-                case "OAuth2Injection":
-                    self.authenticationHandler = new OAuth2InjectionAuthentication_1.OAuth2InjectionAuthentication(credentials, self);
-                    break;
             }
+        },
+        login: async (data) => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.login(data);
+        },
+        logout: async () => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.logout();
+        },
+        getAccessToken: async () => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.getAccessToken();
+        },
+        getRefreshToken: () => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.getRefreshToken();
+        },
+        isLoggedIn: async () => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.isLoggedIn();
+        },
+        getRealtimeToken: (options) => (GenericAPIFn_1.GenericAPIFn("/auth/realtimetoken", "POST", self))(undefined, options),
+        webfinger: (args, options) => (GenericAPIFn_1.GenericAPIFn(`/.well-known/webfinger?${rest_1.stringifyQuery(args)}`, "GET", self))(undefined, Object.assign({ withAuthentication: false }, options)),
+        getAuthorizationCode: async (data) => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.getAuthorizationCode(data);
         }
     };
 }

package/build/authentication/BasicAuthentication/BasicAuthentication.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicAuthentication = void 0;
+exports.BasicAuthentication = function (credentials, self) {
+    if (!(this instanceof exports.BasicAuthentication)) {
+        return new exports.BasicAuthentication(credentials, self);
+    }
+    else {
+        self.credentials = {
+            username: credentials.username,
+            password: credentials.password,
+            type: credentials.type,
+        };
+        const BasicAuthentication = function () { };
+        BasicAuthentication.prototype.getAuthenticationHeaders = async () => {
+            const headers = {};
+            let credential = `${credentials.username}:${credentials.password}`;
+            if (Buffer) {
+                credential = Buffer.from(credential, "binary").toString('base64');
+            }
+            else {
+                credential = btoa(credential);
+            }
+            headers["Authorization"] = `Basic ${credential}`;
+            return headers;
+        };
+        return new BasicAuthentication(credentials, self);
+    }
+};
+exports.default = exports.BasicAuthentication;
+//# sourceMappingURL=BasicAuthentication.js.map

package/build/authentication/BasicAuthentication/IBasicAuthentication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IBasicAuthentication.js.map

package/build/authentication/OAuth2/IGetAuthorizationCodeParameters.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IGetAuthorizationCodeParameters.js.map

package/build/authentication/OAuth2/ILoginByAuthorizationCodeParameters.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ILoginByAuthorizationCodeParameters.js.map

package/build/authentication/OAuth2/ILoginByClientCredentialsParameters.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ILoginByClientCredentialsParameters.js.map

package/build/authentication/OAuth2/ILoginByPasswordParameters.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ILoginByPasswordParameters.js.map

package/build/authentication/OAuth2/ILoginByRefreshTokenParameters.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ILoginByRefreshTokenParameters.js.map

package/build/authentication/OAuth2/IOAuth2AuthorizationCodeGrantRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * The client makes a request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2AuthorizationCodeGrantRequest.js.map

package/build/authentication/OAuth2/IOAuth2ClientCredentialsGrantAccessTokenRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * The client makes a request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.3.2
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2ClientCredentialsGrantAccessTokenRequest.js.map

package/build/authentication/OAuth2/IOAuth2ClientPassword.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2ClientPassword.js.map

package/build/authentication/OAuth2/IOAuth2ErrorResponse.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Errors = void 0;
+exports.OAuth2Errors = [
+    /**
+     * The request is missing a required parameter, includes an unsupported parameter
+     * value, or is otherwise malformed.
+     */
+    "invalid_request",
+    /**
+     * The client is not authorized to request an authorization code using this method.
+     */
+    "unauthorized_client",
+    /**
+     * The resource owner or authorization server denied the request.
+     */
+    "access_denied",
+    /**
+     * The authorization server does not support obtaining an authorization code using
+     * this method.
+     */
+    "unsupported_response_type",
+    /**
+     * The requested scope is invalid, unknown, or malformed.
+     */
+    "invalid_scope",
+    /**
+     * The authorization server encountered an unexpected
+     * condition that prevented it from fulfilling the request.
+     * (This error code is needed because a 500 Internal Server
+     * Error HTTP status code cannot be returned to the client
+     * via an HTTP redirect.)
+     */
+    "server_error",
+    /**
+     * The authorization server is currently unable to handle the request because of a
+     * temporary overloading or maintenance of the server.
+     */
+    "temporarily_unavailable",
+];
+//# sourceMappingURL=IOAuth2ErrorResponse.js.map

package/build/authentication/OAuth2/IOAuth2GetAuthorizationCodeRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * The client makes a request to the authorize endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2GetAuthorizationCodeRequest.js.map

package/build/authentication/OAuth2/IOAuth2PasswordGrantAccessTokenRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * The client makes a request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.3.2
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2PasswordGrantAccessTokenRequest.js.map

package/build/authentication/OAuth2/IOAuth2RefreshAccessTokenRequest.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * If the authorization server issued a refresh token to the client, the
+ * client makes a refresh request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-6
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2RefreshAccessTokenRequest.js.map

package/build/authentication/OAuth2/IOAuth2SuccessResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOAuth2SuccessResponse.js.map

package/build/authentication/OAuth2/OAuth2Authentication.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Authentication = void 0;
+/* Node Modules */
+const querystring_1 = require("querystring");
+/* Custom Modules */
+const OAuth2Error_1 = require("./OAuth2Error");
+const HttpStatusCode_1 = require("../../shared/helper/HttpStatusCode");
+const errors_1 = require("../../shared/errors");
+const IOAuth2ErrorResponse_1 = require("./IOAuth2ErrorResponse");
+const expiryBuffer = 8;
+exports.OAuth2Authentication = function (credentials, self) {
+    if (!(this instanceof exports.OAuth2Authentication)) {
+        return new exports.OAuth2Authentication(credentials, self);
+    }
+    else {
+        self.refreshTokenSingleton = null;
+        self.credentials = {
+            type: credentials.type,
+            clientId: credentials.clientId,
+            clientSecret: credentials.clientSecret,
+        };
+        self.tokenData = {};
+        const refreshTokenGrant = async (data) => {
+            const { clientId, clientSecret, refreshToken } = data;
+            const formFields = {
+                grant_type: "refresh_token",
+                refresh_token: refreshToken,
+                client_id: clientId,
+                client_secret: clientSecret,
+            };
+            return await request(formFields, {
+                maxRetries: Infinity,
+                retryDelay: () => 3000,
+            });
+        };
+        const request = async (formFields, options) => {
+            const payload = querystring_1.stringify(formFields);
+            const httpAdapter = self.getHttpAdapter();
+            let url;
+            if (isAuthorizationRequest(formFields)) {
+                url = "/auth/oauth2/authorize";
+            }
+            else {
+                url = "/auth/oauth2/token";
+            }
+            const requestData = Object.assign({ headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                }, method: "POST", url, data: payload }, options);
+            //@ts-ignore - organisationId
+            if (formFields.organisationId) {
+                //@ts-ignore - organisationId
+                requestData.headers["organisation-id"] = formFields.organisationId;
+                //@ts-ignore - organisationId
+                delete formFields.organisationId;
+                requestData.data = querystring_1.stringify(formFields);
+            }
+            const response = await httpAdapter.request(requestData, self);
+            if (response.status === HttpStatusCode_1.HttpStatusCode.OK) {
+                const result = response.data;
+                result.expires_at = Date.now() + (result.expires_in - expiryBuffer) * 1000;
+                return result;
+            }
+            if (typeof response.data.error === "string") {
+                const error = response.data.error;
+                if (IOAuth2ErrorResponse_1.OAuth2Errors.includes(error.error)) {
+                    throw new OAuth2Error_1.OAuth2Error();
+                }
+            }
+        };
+        const isAccessTokenExpired = (tokenData) => {
+            var _a;
+            return Date.now() > ((_a = tokenData.expires_at) !== null && _a !== void 0 ? _a : 0);
+        };
+        const OAuth2Authentication = function () { };
+        OAuth2Authentication.prototype.getAuthenticationHeaders = async () => {
+            const headers = {};
+            if ((self === null || self === void 0 ? void 0 : self.credentials.type) === "OAuth2") {
+                await getToken();
+                headers["Authorization"] = `${self.tokenData.token_type} ${self.tokenData.access_token}`;
+            }
+            return headers;
+        };
+        OAuth2Authentication.prototype.login = async (parameters) => {
+            const { clientId, clientSecret, } = self.credentials;
+            switch (parameters.type) {
+                case "password":
+                    {
+                        const { username, password, rememberMe, organisationId } = parameters;
+                        const formFields = {
+                            grant_type: "password",
+                            username: username,
+                            password: password,
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                            rememberMe,
+                            organisationId
+                        };
+                        self.tokenData = await request(formFields, {
+                            maxRetries: 0,
+                        });
+                    }
+                    break;
+                case "refreshToken":
+                    {
+                        const { refreshToken } = parameters;
+                        const credentials = self.credentials;
+                        const result = await refreshTokenGrant({
+                            clientId: credentials.clientId,
+                            clientSecret: credentials.clientSecret,
+                            refreshToken,
+                        });
+                        self.tokenData = Object.assign(Object.assign(Object.assign({}, self.tokenData), { refresh_token: refreshToken }), result);
+                    }
+                    break;
+                case "authorizationCode":
+                    {
+                        const { code, redirectUri, } = parameters;
+                        const formFields = {
+                            grant_type: "authorization_code",
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                            code,
+                            redirect_uri: redirectUri
+                        };
+                        self.tokenData = await request(formFields, {
+                            maxRetries: 0,
+                        });
+                    }
+                    break;
+                case "clientCredentials":
+                    {
+                        const { scope } = parameters;
+                        const formFields = {
+                            grant_type: "client_credentials",
+                            scope: scope,
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                        };
+                        self.tokenData = await request(formFields, {
+                            maxRetries: 0,
+                        });
+                    }
+                    break;
+            }
+        };
+        OAuth2Authentication.prototype.getAuthorizationCode = async (parameters) => {
+            const { username, password, redirectUri, state, organisationId } = parameters;
+            const { clientId, } = self.credentials;
+            const formFields = {
+                response_type: "code",
+                username: username,
+                password: password,
+                client_id: clientId,
+                state,
+                organisationId
+            };
+            if (redirectUri) {
+                formFields.redirect_uri = redirectUri;
+            }
+            const code = await request(formFields, {
+                maxRetries: 0
+            });
+            return code;
+        };
+        const getToken = async () => {
+            if ((self === null || self === void 0 ? void 0 : self.credentials.type) === "OAuth2") {
+                if (self.refreshTokenSingleton !== null) {
+                    await self.refreshTokenSingleton;
+                }
+                /*
+                 * Check if AccessToken is still valid and if not trigger an refresh token grant flow
+                 */
+                if (isAccessTokenExpired(self.tokenData)) {
+                    const credentials = self.credentials;
+                    if (!self.tokenData.refresh_token) {
+                        throw new errors_1.UnauthorizedError("No RefreshToken provided.");
+                    }
+                    if (self.refreshTokenSingleton === null) {
+                        self.refreshTokenSingleton = new Promise(function (resolve, reject) {
+                            refreshTokenGrant({
+                                clientId: credentials.clientId,
+                                clientSecret: credentials.clientSecret,
+                                refreshToken: self.tokenData.refresh_token,
+                            })
+                                .then(result => {
+                                self.tokenData = Object.assign(Object.assign({}, self.tokenData), result);
+                                self.refreshTokenSingleton = null;
+                                resolve();
+                            })
+                                .catch(reason => {
+                                self.refreshTokenSingleton = null;
+                                self.tokenData = {};
+                                reject(reason);
+                            });
+                        });
+                        await self.refreshTokenSingleton;
+                    }
+                }
+            }
+            return self.tokenData;
+        };
+        const isAuthorizationRequest = (value) => (value === null || value === void 0 ? void 0 : value.response_type) === "code";
+        OAuth2Authentication.prototype.getAccessToken = async () => {
+            const token = await getToken();
+            return token.access_token;
+        };
+        OAuth2Authentication.prototype.getRefreshToken = () => {
+            var _a;
+            return (_a = self.tokenData) === null || _a === void 0 ? void 0 : _a.refresh_token;
+        };
+        OAuth2Authentication.prototype.isLoggedIn = async () => {
+            var _a;
+            return !!((_a = self.tokenData) === null || _a === void 0 ? void 0 : _a.refresh_token);
+        };
+        OAuth2Authentication.prototype.logout = async () => {
+            if ((self === null || self === void 0 ? void 0 : self.credentials.type) === "OAuth2" &&
+                self.tokenData.refresh_token) {
+                const httpAdapter = self.getHttpAdapter();
+                const requestData = {
+                    method: "POST",
+                    url: "/auth/oauth2/revoke",
+                    data: {
+                        token: self.tokenData.refresh_token,
+                    },
+                    maxRetries: 3,
+                    retryDelay: () => 0,
+                };
+                // reset tokenData to avoid multiple revoke calls
+                self.tokenData = {};
+                await httpAdapter.request(requestData, self);
+            }
+        };
+        return new OAuth2Authentication(credentials, self);
+    }
+};
+exports.default = exports.OAuth2Authentication;
+//# sourceMappingURL=OAuth2Authentication.js.map

package/build/authentication/OAuth2/OAuth2Error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Error = void 0;
+class OAuth2Error extends Error {
+    constructor() {
+        super();
+    }
+}
+exports.OAuth2Error = OAuth2Error;
+//# sourceMappingURL=OAuth2Error.js.map

package/build/authentication/OAuth2/TOAuth2AccessTokenType.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TOAuth2AccessTokenType.js.map