openvsx-webui-test 0.19.0-dev.2 → 0.20.0-dev.0

package/lib/extension-registry-service.js

@@ -7,15 +7,6 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { isError, } from './extension-registry-types';
 import { createAbsoluteURL, addQuery } from './utils';
 import { sendRequest } from './server-request';
@@ -24,7 +15,7 @@ export class ExtensionRegistryService {
         this.serverUrl = serverUrl;
         this.admin = new AdminConstructor(this);
     }
-    getLoginProviders(abortController) {
+    async getLoginProviders(abortController) {
         const endpoint = createAbsoluteURL([this.serverUrl, 'login-providers']);
         return sendRequest({ abortController, endpoint });
     }
@@ -41,52 +32,48 @@ export class ExtensionRegistryService {
         }
         return createAbsoluteURL(arr);
     }
-    getNamespaceDetails(abortController, name) {
+    async getNamespaceDetails(abortController, name) {
         const endpoint = createAbsoluteURL([this.serverUrl, 'api', name, 'details']);
         return sendRequest({ abortController, endpoint });
     }
-    setNamespaceDetails(abortController, endpoint, details) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                payload: details,
-                credentials: true,
-                endpoint,
-                headers
-            });
-        });
-    }
-    setNamespaceLogo(abortController, endpoint, logoFile, logoName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            const form = new FormData();
-            form.append('file', logoFile, logoName);
-            endpoint = createAbsoluteURL([endpoint, 'logo']);
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                payload: form,
-                credentials: true,
-                endpoint,
-                headers
-            });
-        });
-    }
-    search(abortController, filter) {
+    async setNamespaceDetails(abortController, endpoint, details) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: details,
+            credentials: true,
+            endpoint,
+            headers
+        });
+    }
+    async setNamespaceLogo(abortController, endpoint, logoFile, logoName) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        const form = new FormData();
+        form.append('file', logoFile, logoName);
+        endpoint = createAbsoluteURL([endpoint, 'logo']);
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: form,
+            credentials: true,
+            endpoint,
+            headers
+        });
+    }
+    async search(abortController, filter) {
         const query = [];
         if (filter) {
             if (filter.query)
@@ -105,10 +92,10 @@ export class ExtensionRegistryService {
         const endpoint = createAbsoluteURL([this.serverUrl, 'api', '-', 'search'], query);
         return sendRequest({ abortController, endpoint });
     }
-    getExtensionDetail(abortController, extensionUrl) {
+    async getExtensionDetail(abortController, extensionUrl) {
         return sendRequest({ abortController, endpoint: extensionUrl });
     }
-    getExtensionReadme(abortController, extension) {
+    async getExtensionReadme(abortController, extension) {
         return sendRequest({
             abortController,
             endpoint: extension.files.readme,
@@ -116,7 +103,7 @@ export class ExtensionRegistryService {
             followRedirect: true
         });
     }
-    getExtensionChangelog(abortController, extension) {
+    async getExtensionChangelog(abortController, extension) {
         return sendRequest({
             abortController,
             endpoint: extension.files.changelog,
@@ -124,7 +111,7 @@ export class ExtensionRegistryService {
             followRedirect: true
         });
     }
-    getExtensionIcon(abortController, extension) {
+    async getExtensionIcon(abortController, extension) {
         if (!extension.files.icon) {
             return Promise.resolve(undefined);
         }
@@ -157,204 +144,204 @@ export class ExtensionRegistryService {
             'Notebooks'
         ];
     }
-    getExtensionReviews(abortController, extension) {
+    async getExtensionReviews(abortController, extension) {
         return sendRequest({ abortController, endpoint: extension.reviewsUrl });
     }
-    postReview(abortController, review, postReviewUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                payload: review,
-                credentials: true,
-                endpoint: postReviewUrl,
-                headers
-            });
-        });
-    }
-    deleteReview(abortController, deleteReviewUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: deleteReviewUrl,
-                headers
-            });
-        });
-    }
-    deleteUserReview(abortController, extension, user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.serverUrl, 'admin', 'extension', extension.namespace, extension.name, 'review', user.provider || 'github', user.loginName, 'delete']),
-                headers
-            });
+    async postReview(abortController, review, postReviewUrl) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: review,
+            credentials: true,
+            endpoint: postReviewUrl,
+            headers
         });
     }
-    getUser(abortController) {
+    async deleteReview(abortController, deleteReviewUrl) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: deleteReviewUrl,
+            headers
+        });
+    }
+    async deleteUserReview(abortController, extension, user) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.serverUrl, 'admin', 'extension', extension.namespace, extension.name, 'review', user.provider || 'github', user.loginName, 'delete']),
+            headers
+        });
+    }
+    async getUser(abortController) {
         return sendRequest({
             abortController,
             endpoint: createAbsoluteURL([this.serverUrl, 'user']),
             credentials: true
         });
     }
-    getUserAuthError(abortController) {
+    async getUserAuthError(abortController) {
         return sendRequest({
             abortController,
             endpoint: createAbsoluteURL([this.serverUrl, 'user', 'auth-error']),
             credentials: true
         });
     }
-    getUserByName(abortController, name) {
+    async getUserByName(abortController, name) {
         return sendRequest({
             abortController,
             endpoint: createAbsoluteURL([this.serverUrl, 'user', 'search', name]),
             credentials: true
         });
     }
-    getAccessTokens(abortController, user) {
+    async getAccessTokens(abortController, user) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: user.tokensUrl
         });
     }
-    createAccessToken(abortController, user, description) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            const endpoint = addQuery(user.createTokenUrl, [{ key: 'description', value: description }]);
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint,
-                headers
-            });
-        });
-    }
-    deleteAccessToken(abortController, token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: token.deleteTokenUrl,
-                headers
-            });
-        });
-    }
-    deleteAllAccessTokens(abortController, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return yield Promise.all(tokens.map(token => sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: token.deleteTokenUrl,
-                headers
-            })));
+    async createAccessToken(abortController, user, description) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        const endpoint = addQuery(user.createTokenUrl, [{ key: 'description', value: description }]);
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint,
+            headers
         });
     }
-    getCsrfToken(abortController) {
+    async deleteAccessToken(abortController, token) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: token.deleteTokenUrl,
+            headers
+        });
+    }
+    async deleteAllAccessTokens(abortController, tokens) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return await Promise.all(tokens.map(token => sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: token.deleteTokenUrl,
+            headers
+        })));
+    }
+    async getCsrfToken(abortController) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: createAbsoluteURL([this.serverUrl, 'user', 'csrf'])
         });
     }
-    getNamespaces(abortController) {
+    async getNamespaces(abortController) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: createAbsoluteURL([this.serverUrl, 'user', 'namespaces'])
         });
     }
-    getNamespaceMembers(abortController, namespace) {
+    async getCustomers(abortController) {
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.serverUrl, 'user', 'customers'])
+        });
+    }
+    async getUsageStats(abortController, customerName, date) {
+        const query = [];
+        query.push({ key: 'date', value: date.toISOString() });
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.serverUrl, 'user', 'customers', customerName, 'usage'], query),
+            credentials: true
+        }, false);
+    }
+    async getNamespaceMembers(abortController, namespace) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: namespace.membersUrl
         });
     }
-    setNamespaceMember(abortController, endpoint, user, role) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            const query = [
-                { key: 'user', value: user.loginName },
-                { key: 'provider', value: user.provider },
-                { key: 'role', value: role }
-            ];
-            return sendRequest({
-                abortController,
-                headers,
-                method: 'POST',
-                credentials: true,
-                endpoint: addQuery(endpoint, query)
-            });
-        });
-    }
-    signPublisherAgreement(abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.serverUrl, 'user', 'publisher-agreement']),
-                headers
-            });
+    async setNamespaceMember(abortController, endpoint, user, role) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        const query = [
+            { key: 'user', value: user.loginName },
+            { key: 'provider', value: user.provider },
+            { key: 'role', value: role }
+        ];
+        return sendRequest({
+            abortController,
+            headers,
+            method: 'POST',
+            credentials: true,
+            endpoint: addQuery(endpoint, query)
         });
     }
-    getStaticContent(abortController, url) {
+    async signPublisherAgreement(abortController) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.serverUrl, 'user', 'publisher-agreement']),
+            headers
+        });
+    }
+    async getStaticContent(abortController, url) {
         return sendRequest({
             abortController,
             endpoint: url,
@@ -362,229 +349,205 @@ export class ExtensionRegistryService {
             followRedirect: true
         });
     }
-    publishExtension(abortController, extensionPackage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/octet-stream'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                payload: extensionPackage,
-                headers: headers,
-                endpoint: createAbsoluteURL([this.serverUrl, 'api', 'user', 'publish'])
-            }, false); // do not retry publishing an extension but show the explicit error received
-        });
-    }
-    createNamespace(abortController, name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                payload: { name: name },
-                headers: headers,
-                endpoint: createAbsoluteURL([this.serverUrl, 'api', 'user', 'namespace', 'create'])
-            });
-        });
-    }
-    getExtensions(abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'GET',
-                credentials: true,
-                headers: headers,
-                endpoint: createAbsoluteURL([this.serverUrl, 'user', 'extensions'])
-            });
-        });
-    }
-    getExtension(abortController, namespace, extension) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'GET',
-                credentials: true,
-                headers: headers,
-                endpoint: createAbsoluteURL([this.serverUrl, 'user', 'extension', namespace, extension])
-            });
-        });
-    }
-    deleteExtensions(abortController, req) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.serverUrl, 'user', 'extension', req.namespace, req.extension, 'delete']),
-                headers,
-                payload: req.targetPlatformVersions
-            });
+    async publishExtension(abortController, extensionPackage) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/octet-stream'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            payload: extensionPackage,
+            headers: headers,
+            endpoint: createAbsoluteURL([this.serverUrl, 'api', 'user', 'publish'])
+        }, false); // do not retry publishing an extension but show the explicit error received
+    }
+    async createNamespace(abortController, name) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            payload: { name: name },
+            headers: headers,
+            endpoint: createAbsoluteURL([this.serverUrl, 'api', 'user', 'namespace', 'create'])
         });
     }
-    getRegistryVersion(abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = createAbsoluteURL([this.serverUrl, 'api', 'version']);
-            return sendRequest({ abortController, endpoint });
+    async getExtensions(abortController) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'GET',
+            credentials: true,
+            headers: headers,
+            endpoint: createAbsoluteURL([this.serverUrl, 'user', 'extensions'])
         });
     }
+    async getExtension(abortController, namespace, extension) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'GET',
+            credentials: true,
+            headers: headers,
+            endpoint: createAbsoluteURL([this.serverUrl, 'user', 'extension', namespace, extension])
+        });
+    }
+    async deleteExtensions(abortController, req) {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.serverUrl, 'user', 'extension', req.namespace, req.extension, 'delete']),
+            headers,
+            payload: req.targetPlatformVersions
+        });
+    }
+    async getRegistryVersion(abortController) {
+        const endpoint = createAbsoluteURL([this.serverUrl, 'api', 'version']);
+        return sendRequest({ abortController, endpoint });
+    }
 }
 export class AdminServiceImpl {
     constructor(registry) {
         this.registry = registry;
     }
-    getExtension(abortController, namespace, extension) {
+    async getExtension(abortController, namespace, extension) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'extension', namespace, extension])
         });
     }
-    deleteExtensions(abortController, req) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'extension', req.namespace, req.extension, 'delete']),
-                headers,
-                payload: req.targetPlatformVersions
-            });
+    async deleteExtensions(abortController, req) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'extension', req.namespace, req.extension, 'delete']),
+            headers,
+            payload: req.targetPlatformVersions
         });
     }
-    getNamespace(abortController, name) {
+    async getNamespace(abortController, name) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'namespace', name])
         });
     }
-    createNamespace(abortController, namespace) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'create-namespace']),
-                method: 'POST',
-                payload: namespace,
-                headers
-            });
-        });
-    }
-    changeNamespace(abortController, req) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'change-namespace']),
-                method: 'POST',
-                payload: req,
-                headers
-            });
-        });
-    }
-    getPublisherInfo(abortController, provider, login) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return sendRequest({
-                abortController,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'publisher', provider, login]),
-                credentials: true
-            });
-        });
-    }
-    revokePublisherContributions(abortController, provider, login) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'publisher', provider, login, 'revoke']),
-                headers
-            });
-        });
-    }
-    revokeAccessTokens(abortController, provider, login) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {};
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'publisher', provider, login, 'tokens', 'revoke']),
-                headers
-            });
+    async createNamespace(abortController, namespace) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'create-namespace']),
+            method: 'POST',
+            payload: namespace,
+            headers
+        });
+    }
+    async changeNamespace(abortController, req) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'change-namespace']),
+            method: 'POST',
+            payload: req,
+            headers
+        });
+    }
+    async getPublisherInfo(abortController, provider, login) {
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'publisher', provider, login]),
+            credentials: true
+        });
+    }
+    async revokePublisherContributions(abortController, provider, login) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'publisher', provider, login, 'revoke']),
+            headers
+        });
+    }
+    async revokeAccessTokens(abortController, provider, login) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'publisher', provider, login, 'tokens', 'revoke']),
+            headers
         });
     }
-    getAllScans(abortController, params) {
+    async getAllScans(abortController, params) {
         const query = [];
         if (params) {
             if (params.size !== undefined)
@@ -621,14 +584,14 @@ export class AdminServiceImpl {
             endpoint
         });
     }
-    getScan(abortController, scanId) {
+    async getScan(abortController, scanId) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', scanId])
         });
     }
-    getScanCounts(abortController, params) {
+    async getScanCounts(abortController, params) {
         const query = [];
         if (params) {
             if (params.dateStartedFrom)
@@ -651,14 +614,14 @@ export class AdminServiceImpl {
             endpoint
         });
     }
-    getScanFilterOptions(abortController) {
+    async getScanFilterOptions(abortController) {
         return sendRequest({
             abortController,
             credentials: true,
             endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'filterOptions'])
         });
     }
-    getFiles(abortController, params) {
+    async getFiles(abortController, params) {
         const query = [];
         if (params) {
             if (params.size !== undefined)
@@ -689,7 +652,7 @@ export class AdminServiceImpl {
             endpoint
         });
     }
-    getFileCounts(abortController, params) {
+    async getFileCounts(abortController, params) {
         const query = [];
         if (params) {
             if (params.dateDecidedFrom)
@@ -704,232 +667,258 @@ export class AdminServiceImpl {
             endpoint
         });
     }
-    makeScanDecision(abortController, request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'decisions']),
-                headers,
-                payload: request
-            });
-        });
-    }
-    makeFileDecision(abortController, request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
-                headers,
-                payload: request
-            });
-        });
-    }
-    deleteFileDecisions(abortController, request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'DELETE',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
-                headers,
-                payload: request
-            });
-        });
-    }
-    getTiers(abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return sendRequest({
-                abortController,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers']),
-                credentials: true
-            }, false);
-        });
-    }
-    createTier(abortController, tier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                payload: tier,
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', 'create']),
-                headers
-            }, false);
-        });
-    }
-    updateTier(abortController, name, tier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'PUT',
-                payload: tier,
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', name]),
-                headers
-            }, false);
-        });
-    }
-    deleteTier(abortController, name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'DELETE',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', name]),
-                headers
-            }, false);
-        });
-    }
-    getCustomers(abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return sendRequest({
-                abortController,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers']),
-                credentials: true
-            }, false);
-        });
-    }
-    createCustomer(abortController, customer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'POST',
-                payload: customer,
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', 'create']),
-                headers
-            }, false);
-        });
-    }
-    updateCustomer(abortController, name, customer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'PUT',
-                payload: customer,
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
-                headers
-            }, false);
-        });
-    }
-    deleteCustomer(abortController, name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const csrfResponse = yield this.registry.getCsrfToken(abortController);
-            const headers = {
-                'Content-Type': 'application/json;charset=UTF-8'
-            };
-            if (!isError(csrfResponse)) {
-                const csrfToken = csrfResponse;
-                headers[csrfToken.header] = csrfToken.value;
-            }
-            return sendRequest({
-                abortController,
-                method: 'DELETE',
-                credentials: true,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
-                headers
-            }, false);
+    async makeScanDecision(abortController, request) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+    async makeFileDecision(abortController, request) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+    async deleteFileDecisions(abortController, request) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
+            headers,
+            payload: request
         });
     }
+    async getTiers(abortController) {
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers']),
+            credentials: true
+        }, false);
+    }
+    async createTier(abortController, tier) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: tier,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', 'create']),
+            headers
+        }, false);
+    }
+    async updateTier(abortController, name, tier) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'PUT',
+            payload: tier,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', name]),
+            headers
+        }, false);
+    }
+    async deleteTier(abortController, name) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', name]),
+            headers
+        }, false);
+    }
+    async getCustomers(abortController) {
+        return await sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers']),
+            credentials: true
+        }, false);
+    }
+    async getCustomer(abortController, name) {
+        return await sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
+            credentials: true
+        }, false);
+    }
+    async createCustomer(abortController, customer) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: customer,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', 'create']),
+            headers
+        }, false);
+    }
+    async updateCustomer(abortController, name, customer) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'PUT',
+            payload: customer,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
+            headers
+        }, false);
+    }
+    async deleteCustomer(abortController, name) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
+            headers
+        }, false);
+    }
+    async getCustomerMembers(abortController, name) {
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name, "members"]),
+        }, false);
+    }
+    async addCustomerMember(abortController, name, user) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        const query = [
+            { key: 'user', value: user.loginName },
+            { key: 'provider', value: user.provider },
+        ];
+        return sendRequest({
+            abortController,
+            headers,
+            method: 'POST',
+            credentials: true,
+            endpoint: addQuery(createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name, "add-member"]), query),
+        }, false);
+    }
+    async removeCustomerMember(abortController, name, user) {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        const query = [
+            { key: 'user', value: user.loginName },
+            { key: 'provider', value: user.provider },
+        ];
+        return sendRequest({
+            abortController,
+            headers,
+            method: 'POST',
+            credentials: true,
+            endpoint: addQuery(createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name, "remove-member"]), query),
+        }, false);
+    }
     /**
      * Get usage stats for a customer within an optional date range.
      */
-    getUsageStats(abortController, customerName, date) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const query = [];
-            query.push({ key: 'date', value: date.toISOString() });
-            return sendRequest({
-                abortController,
-                endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', customerName, 'usage'], query),
-                credentials: true
-            }, false);
-        });
-    }
-    getLogs(abortController_1) {
-        return __awaiter(this, arguments, void 0, function* (abortController, page = 0, size = 20, period) {
-            const query = [
-                { key: 'page', value: page },
-                { key: 'size', value: size }
-            ];
-            if (period) {
-                query.push({ key: 'period', value: period });
-            }
-            const endpoint = addQuery(createAbsoluteURL([this.registry.serverUrl, 'admin', 'logs']), query);
-            return sendRequest({
-                abortController,
-                endpoint,
-                credentials: true
-            }, false);
-        });
+    async getUsageStats(abortController, customerName, date) {
+        const query = [];
+        query.push({ key: 'date', value: date.toISOString() });
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', customerName, 'usage'], query),
+            credentials: true
+        }, false);
+    }
+    async getLogs(abortController, page = 0, size = 20, period) {
+        const query = [
+            { key: 'page', value: page },
+            { key: 'size', value: size }
+        ];
+        if (period) {
+            query.push({ key: 'period', value: period });
+        }
+        const endpoint = addQuery(createAbsoluteURL([this.registry.serverUrl, 'admin', 'logs']), query);
+        return sendRequest({
+            abortController,
+            endpoint,
+            credentials: true
+        }, false);
     }
 }
 //# sourceMappingURL=extension-registry-service.js.map