@casual-simulation/aux-records 3.4.6-alpha.14601027727 → 3.5.0-alpha.15117651144

package/PrivoClient.js

@@ -4,15 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 { Issuer, generators } from 'openid-client';
 import { v4 as uuid } from 'uuid';
 import axios from 'axios';
@@ -36,481 +27,453 @@ export class PrivoClient {
         this._store = store;
         this._config = configStore;
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            this._issuer = yield Issuer.discover(config.publicEndpoint);
-            this._redirectUri = config.redirectUri;
-            this._openid = new this._issuer.Client({
-                client_id: config.clientId,
-                client_secret: config.clientSecret,
-                redirect_uris: [this._redirectUri],
-                response_types: ['code'],
-            });
+    async init() {
+        const config = await this._config.getPrivoConfiguration();
+        this._issuer = await Issuer.discover(config.publicEndpoint);
+        this._redirectUri = config.redirectUri;
+        this._openid = new this._issuer.Client({
+            client_id: config.clientId,
+            client_secret: config.clientSecret,
+            redirect_uris: [this._redirectUri],
+            response_types: ['code'],
         });
     }
-    resendConsentRequest(requesterServiceId, approverServiceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/api/v1.0/consent/resend`;
-            const result = yield axios.post(url, {
-                requester_service_id: requesterServiceId,
-                approver_service_id: approverServiceId,
-            }, {
-                headers,
-                validateStatus: (status) => status < 500,
-            });
-            if (result.status >= 400) {
-                console.error(`[PrivoClient] [resendConsentRequest] Error resending consent request: ${result.status} ${result.statusText}`, result.data);
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'The request contains one or more invalid fields.',
-                };
-            }
+    async resendConsentRequest(requesterServiceId, approverServiceId) {
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/api/v1.0/consent/resend`;
+        const result = await axios.post(url, {
+            requester_service_id: requesterServiceId,
+            approver_service_id: approverServiceId,
+        }, {
+            headers,
+            validateStatus: (status) => status < 500,
+        });
+        if (result.status >= 400) {
+            console.error(`[PrivoClient] [resendConsentRequest] Error resending consent request: ${result.status} ${result.statusText}`, result.data);
             return {
-                success: true,
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'The request contains one or more invalid fields.',
             };
-        });
+        }
+        return {
+            success: true,
+        };
     }
-    createChildAccount(request) {
+    async createChildAccount(request) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/api/v1.0/account/parent`;
-            const result = yield axios.post(url, {
-                role_identifier: config.roleIds.parent,
-                email: request.parentEmail,
-                send_congratulations_email: true,
-                minor_registrations: [
-                    {
-                        send_parent_email: true,
-                        role_identifier: config.roleIds.child,
-                        first_name: request.childFirstName,
-                        email: request.childEmail,
-                        birth_date_yyyymmdd: DateTime.fromJSDate(request.childDateOfBirth).toFormat('yyyyMMdd'),
-                        features: request.featureIds.map((f) => ({
-                            feature_identifier: f,
-                        })),
-                        attributes: [
-                            {
-                                name: 'displayName',
-                                value: request.childDisplayName,
-                            },
-                        ],
-                    },
-                ],
-            }, {
-                headers,
-                validateStatus: (status) => status < 500,
-            });
-            if (result.status >= 400) {
-                console.error(`[PrivoClient] [createChildAccount] Error creating child account: ${result.status} ${result.statusText}`, result.data);
-                if (result.status === 412) {
-                    return {
-                        success: false,
-                        errorCode: 'child_email_already_exists',
-                        errorMessage: 'The child email already exists.',
-                    };
-                }
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/api/v1.0/account/parent`;
+        const result = await axios.post(url, {
+            role_identifier: config.roleIds.parent,
+            email: request.parentEmail,
+            send_congratulations_email: true,
+            minor_registrations: [
+                {
+                    send_parent_email: true,
+                    role_identifier: config.roleIds.child,
+                    first_name: request.childFirstName,
+                    email: request.childEmail,
+                    birth_date_yyyymmdd: DateTime.fromJSDate(request.childDateOfBirth).toFormat('yyyyMMdd'),
+                    features: request.featureIds.map((f) => ({
+                        feature_identifier: f,
+                    })),
+                    attributes: [
+                        {
+                            name: 'displayName',
+                            value: request.childDisplayName,
+                        },
+                    ],
+                },
+            ],
+        }, {
+            headers,
+            validateStatus: (status) => status < 500,
+        });
+        if (result.status >= 400) {
+            console.error(`[PrivoClient] [createChildAccount] Error creating child account: ${result.status} ${result.statusText}`, result.data);
+            if (result.status === 412) {
                 return {
                     success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'The request contains one or more invalid fields.',
+                    errorCode: 'child_email_already_exists',
+                    errorMessage: 'The child email already exists.',
                 };
             }
-            const data = result.data;
-            const schema = z.object({
-                to: z.object({
-                    service_id: z.string(),
-                    connected_profiles: z
-                        .array(z.object({
-                        service_id: z.string(),
-                        update_password_link: z.string(),
-                        features: z.array(z.object({
-                            feature_identifier: z.string(),
-                            on: z.boolean(),
-                        })),
-                        consent_meta: z
-                            .object({
-                            consent_url: z
-                                .string()
-                                .optional()
-                                .nullable(),
-                        })
-                            .optional()
-                            .nullable(),
-                    }))
-                        .min(1),
-                }),
-            });
-            const validated = schema.parse(data);
             return {
-                success: true,
-                parentServiceId: validated.to.service_id,
-                childServiceId: validated.to.connected_profiles[0].service_id,
-                updatePasswordLink: validated.to.connected_profiles[0].update_password_link,
-                features: validated.to.connected_profiles[0].features.map((f) => ({
-                    featureId: f.feature_identifier,
-                    on: f.on === true || f.on === 'true',
-                })),
-                consentUrl: (_a = validated.to.connected_profiles[0].consent_meta) === null || _a === void 0 ? void 0 : _a.consent_url,
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'The request contains one or more invalid fields.',
             };
-        });
-    }
-    createAdultAccount(request) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/api/v1.0/account`;
-            const result = yield axios.post(url, {
-                role_identifier: config.roleIds.adult,
-                email: request.adultEmail,
-                send_registration_email: true,
-                send_congratulations_email: true,
-                birth_date_yyyymmdd: DateTime.fromJSDate(request.adultDateOfBirth).toFormat('yyyyMMdd'),
-                first_name: request.adultFirstName,
-                features: request.featureIds.map((f) => ({
-                    feature_identifier: f,
-                })),
-                attributes: [
-                    {
-                        name: 'displayName',
-                        value: request.adultDisplayName,
-                    },
-                ],
-            }, {
-                headers,
-                validateStatus: (status) => status < 500,
-            });
-            if (result.status >= 400) {
-                console.error(`[PrivoClient] [createAdultAccount] Error creating adult account: ${result.status} ${result.statusText}`, result.data);
-                if (result.status === 412) {
-                    return {
-                        success: false,
-                        errorCode: 'email_already_exists',
-                        errorMessage: 'The email already exists.',
-                    };
-                }
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'The request contains one or more invalid fields.',
-                };
-            }
-            const data = result.data;
-            const schema = z.object({
-                to: z.object({
+        }
+        const data = result.data;
+        const schema = z.object({
+            to: z.object({
+                service_id: z.string(),
+                connected_profiles: z
+                    .array(z.object({
                     service_id: z.string(),
+                    update_password_link: z.string(),
                     features: z.array(z.object({
                         feature_identifier: z.string(),
                         on: z.boolean(),
                     })),
-                    update_password_link: z.string(),
                     consent_meta: z
                         .object({
-                        consent_url: z.string().optional().nullable(),
+                        consent_url: z
+                            .string()
+                            .optional()
+                            .nullable(),
                     })
                         .optional()
                         .nullable(),
-                }),
-            });
-            const validated = schema.parse(data);
-            return {
-                success: true,
-                adultServiceId: validated.to.service_id,
-                updatePasswordLink: validated.to.update_password_link,
-                features: validated.to.features.map((f) => ({
-                    featureId: f.feature_identifier,
-                    on: f.on === true || f.on === 'true',
-                })),
-                consentUrl: (_a = validated.to.consent_meta) === null || _a === void 0 ? void 0 : _a.consent_url,
-            };
+                }))
+                    .min(1),
+            }),
         });
+        const validated = schema.parse(data);
+        return {
+            success: true,
+            parentServiceId: validated.to.service_id,
+            childServiceId: validated.to.connected_profiles[0].service_id,
+            updatePasswordLink: validated.to.connected_profiles[0].update_password_link,
+            features: validated.to.connected_profiles[0].features.map((f) => ({
+                featureId: f.feature_identifier,
+                on: f.on === true || f.on === 'true',
+            })),
+            consentUrl: (_a = validated.to.connected_profiles[0].consent_meta) === null || _a === void 0 ? void 0 : _a.consent_url,
+        };
     }
-    getUserInfo(serviceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/userinfo`;
-            const result = yield axios.get(url, {
-                params: {
-                    service_id: serviceId,
+    async createAdultAccount(request) {
+        var _a;
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/api/v1.0/account`;
+        const result = await axios.post(url, {
+            role_identifier: config.roleIds.adult,
+            email: request.adultEmail,
+            send_registration_email: true,
+            send_congratulations_email: true,
+            birth_date_yyyymmdd: DateTime.fromJSDate(request.adultDateOfBirth).toFormat('yyyyMMdd'),
+            first_name: request.adultFirstName,
+            features: request.featureIds.map((f) => ({
+                feature_identifier: f,
+            })),
+            attributes: [
+                {
+                    name: 'displayName',
+                    value: request.adultDisplayName,
                 },
-                headers,
-            });
-            const data = result.data;
-            const schema = z.object({
-                sub: z.string(),
-                locale: z.string(),
-                given_name: z.string(),
-                email: z.string().optional().nullable(),
-                email_verified: z.boolean(),
-                role_identifier: z.string(),
-                display_name: z.string(),
-                permissions: z.array(z.object({
-                    on: z.boolean(),
-                    consent_date: z.number(),
+            ],
+        }, {
+            headers,
+            validateStatus: (status) => status < 500,
+        });
+        if (result.status >= 400) {
+            console.error(`[PrivoClient] [createAdultAccount] Error creating adult account: ${result.status} ${result.statusText}`, result.data);
+            if (result.status === 412) {
+                return {
+                    success: false,
+                    errorCode: 'email_already_exists',
+                    errorMessage: 'The email already exists.',
+                };
+            }
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'The request contains one or more invalid fields.',
+            };
+        }
+        const data = result.data;
+        const schema = z.object({
+            to: z.object({
+                service_id: z.string(),
+                features: z.array(z.object({
                     feature_identifier: z.string(),
-                    category: z.string(),
-                    active: z.boolean(),
+                    on: z.boolean(),
                 })),
-            });
-            const validated = schema.parse(data);
-            return {
+                update_password_link: z.string(),
+                consent_meta: z
+                    .object({
+                    consent_url: z.string().optional().nullable(),
+                })
+                    .optional()
+                    .nullable(),
+            }),
+        });
+        const validated = schema.parse(data);
+        return {
+            success: true,
+            adultServiceId: validated.to.service_id,
+            updatePasswordLink: validated.to.update_password_link,
+            features: validated.to.features.map((f) => ({
+                featureId: f.feature_identifier,
+                on: f.on === true || f.on === 'true',
+            })),
+            consentUrl: (_a = validated.to.consent_meta) === null || _a === void 0 ? void 0 : _a.consent_url,
+        };
+    }
+    async getUserInfo(serviceId) {
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/userinfo`;
+        const result = await axios.get(url, {
+            params: {
+                service_id: serviceId,
+            },
+            headers,
+        });
+        const data = result.data;
+        const schema = z.object({
+            sub: z.string(),
+            locale: z.string(),
+            given_name: z.string(),
+            email: z.string().optional().nullable(),
+            email_verified: z.boolean(),
+            role_identifier: z.string(),
+            display_name: z.string(),
+            permissions: z.array(z.object({
+                on: z.boolean(),
+                consent_date: z.number(),
+                feature_identifier: z.string(),
+                category: z.string(),
+                active: z.boolean(),
+            })),
+        });
+        const validated = schema.parse(data);
+        return {
+            serviceId: validated.sub,
+            locale: validated.locale,
+            givenName: validated.given_name,
+            email: validated.email,
+            emailVerified: validated.email_verified,
+            roleIdentifier: validated.role_identifier,
+            displayName: validated.display_name,
+            permissions: validated.permissions.map((p) => ({
+                on: p.on,
+                consentDateSeconds: p.consent_date,
+                featureId: p.feature_identifier,
+                category: p.category,
+                active: p.active,
+            })),
+        };
+    }
+    async lookupServiceId(request) {
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/api/v1.0/account/lookup`;
+        const params = {};
+        if (request.userName) {
+            params.user_name = request.userName;
+        }
+        else if (request.displayName) {
+            params.display_name = request.displayName;
+        }
+        else if (request.email) {
+            params.email = request.email;
+        }
+        else if (request.phoneNumber) {
+            params.phone = request.phoneNumber;
+        }
+        else if (request.externalUserIdentifier) {
+            params.external_user_identifier = request.externalUserIdentifier;
+        }
+        const result = await axios.get(url, {
+            params,
+            headers,
+        });
+        if (result.status === 404) {
+            return null;
+        }
+        const data = result.data;
+        const schema = z.object({
+            sid: z.string(),
+        });
+        const validated = schema.parse(data);
+        return validated.sid;
+    }
+    async generateAuthorizationUrl(state) {
+        const codeVerifier = generators.codeVerifier();
+        const codeChallenge = generators.codeChallenge(codeVerifier);
+        const codeMethod = 'S256';
+        const config = await this._config.getPrivoConfiguration();
+        const scope = config.userTokenScopes;
+        const url = this._openid.authorizationUrl({
+            scope: scope,
+            code_challenge: codeChallenge,
+            code_challenge_method: codeMethod,
+            state,
+        });
+        return {
+            authorizationUrl: url,
+            redirectUrl: this._redirectUri,
+            codeMethod,
+            codeVerifier: codeVerifier,
+            scope: scope,
+        };
+    }
+    async processAuthorizationCallback(request) {
+        const tokens = await this._openid.callback(request.redirectUrl, {
+            code: request.code,
+            state: request.state,
+        }, {
+            state: request.state,
+            code_verifier: request.codeVerifier,
+        });
+        const data = await this._openid.userinfo(tokens.access_token);
+        const schema = z.object({
+            sub: z.string(),
+            locale: z.string(),
+            given_name: z.string().optional().nullable(),
+            email: z.string().optional().nullable(),
+            email_verified: z.boolean(),
+            role_identifier: z.string(),
+            preferred_username: z.string().optional().nullable(),
+            permissions: z
+                .array(z.object({
+                on: z.boolean(),
+                consent_time: z.number().nullable().optional(),
+                request_time: z.number(),
+                feature_identifier: z.string(),
+                feature_category: z.string(),
+                feature_active: z.boolean(),
+            }))
+                .optional()
+                .nullable(),
+        });
+        const validated = schema.parse(data);
+        return {
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            idToken: tokens.id_token,
+            expiresIn: tokens.expires_in,
+            tokenType: tokens.token_type,
+            userInfo: {
                 serviceId: validated.sub,
                 locale: validated.locale,
                 givenName: validated.given_name,
                 email: validated.email,
                 emailVerified: validated.email_verified,
                 roleIdentifier: validated.role_identifier,
-                displayName: validated.display_name,
+                displayName: validated.preferred_username,
                 permissions: validated.permissions.map((p) => ({
                     on: p.on,
-                    consentDateSeconds: p.consent_date,
+                    consentDateSeconds: p.consent_time,
                     featureId: p.feature_identifier,
-                    category: p.category,
-                    active: p.active,
+                    category: p.feature_category,
+                    active: p.feature_active,
                 })),
-            };
-        });
+            },
+        };
     }
-    lookupServiceId(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/api/v1.0/account/lookup`;
-            const params = {};
-            if (request.userName) {
-                params.user_name = request.userName;
-            }
-            else if (request.displayName) {
-                params.display_name = request.displayName;
-            }
-            else if (request.email) {
-                params.email = request.email;
-            }
-            else if (request.phoneNumber) {
-                params.phone = request.phoneNumber;
-            }
-            else if (request.externalUserIdentifier) {
-                params.external_user_identifier = request.externalUserIdentifier;
-            }
-            const result = yield axios.get(url, {
-                params,
-                headers,
-            });
-            if (result.status === 404) {
-                return null;
-            }
-            const data = result.data;
-            const schema = z.object({
-                sid: z.string(),
-            });
-            const validated = schema.parse(data);
-            return validated.sid;
-        });
+    async generateLogoutUrl(token) {
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const url = new URL('/logout', config.publicEndpoint);
+        url.searchParams.set('id_token_hint', token);
+        return url.href;
     }
-    generateAuthorizationUrl(state) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const codeVerifier = generators.codeVerifier();
-            const codeChallenge = generators.codeChallenge(codeVerifier);
-            const codeMethod = 'S256';
-            const config = yield this._config.getPrivoConfiguration();
-            const scope = config.userTokenScopes;
-            const url = this._openid.authorizationUrl({
-                scope: scope,
-                code_challenge: codeChallenge,
-                code_challenge_method: codeMethod,
-                state,
-            });
-            return {
-                authorizationUrl: url,
-                redirectUrl: this._redirectUri,
-                codeMethod,
-                codeVerifier: codeVerifier,
-                scope: scope,
-            };
+    async checkEmail(email) {
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/api/v1.0/account/check/email`;
+        const result = await axios.post(url, { email }, { headers });
+        const data = result.data;
+        // Privo's email API returns invalid profanity information.
+        const schema = z.object({
+            available: z.boolean(),
+            suggestions: z.array(z.string()).optional(),
         });
+        const validated = schema.parse(data);
+        return {
+            available: validated.available,
+            suggestions: validated.suggestions,
+        };
     }
-    processAuthorizationCallback(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tokens = yield this._openid.callback(request.redirectUrl, {
-                code: request.code,
-                state: request.state,
-            }, {
-                state: request.state,
-                code_verifier: request.codeVerifier,
-            });
-            const data = yield this._openid.userinfo(tokens.access_token);
-            const schema = z.object({
-                sub: z.string(),
-                locale: z.string(),
-                given_name: z.string().optional().nullable(),
-                email: z.string().optional().nullable(),
-                email_verified: z.boolean(),
-                role_identifier: z.string(),
-                preferred_username: z.string().optional().nullable(),
-                permissions: z
-                    .array(z.object({
-                    on: z.boolean(),
-                    consent_time: z.number().nullable().optional(),
-                    request_time: z.number(),
-                    feature_identifier: z.string(),
-                    feature_category: z.string(),
-                    feature_active: z.boolean(),
-                }))
-                    .optional()
-                    .nullable(),
-            });
-            const validated = schema.parse(data);
-            return {
-                accessToken: tokens.access_token,
-                refreshToken: tokens.refresh_token,
-                idToken: tokens.id_token,
-                expiresIn: tokens.expires_in,
-                tokenType: tokens.token_type,
-                userInfo: {
-                    serviceId: validated.sub,
-                    locale: validated.locale,
-                    givenName: validated.given_name,
-                    email: validated.email,
-                    emailVerified: validated.email_verified,
-                    roleIdentifier: validated.role_identifier,
-                    displayName: validated.preferred_username,
-                    permissions: validated.permissions.map((p) => ({
-                        on: p.on,
-                        consentDateSeconds: p.consent_time,
-                        featureId: p.feature_identifier,
-                        category: p.feature_category,
-                        active: p.feature_active,
-                    })),
-                },
-            };
+    async checkDisplayName(displayName) {
+        const config = await this._config.getPrivoConfiguration();
+        if (!config) {
+            throw new Error('No Privo configuration found.');
+        }
+        const headers = await this._getRequestHeaders(config);
+        const url = `${config.gatewayEndpoint}/api/v1.0/account/check/display-name`;
+        const result = await axios.post(url, {
+            display_name: displayName,
+            suggest: true,
+        }, { headers });
+        const data = result.data;
+        const schema = z.object({
+            available: z.boolean(),
+            suggestions: z.array(z.string()).optional(),
+            profanity: z.boolean().optional(),
         });
+        const validated = schema.parse(data);
+        return {
+            available: validated.available,
+            profanity: validated.profanity,
+            suggestions: validated.suggestions,
+        };
     }
-    generateLogoutUrl(token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const url = new URL('/logout', config.publicEndpoint);
-            url.searchParams.set('id_token_hint', token);
-            return url.href;
-        });
+    async _getRequestHeaders(config) {
+        const credentials = await this._getClientCredentials(config);
+        if (!credentials) {
+            throw new Error('No Privo credentials found.');
+        }
+        return {
+            Authorization: `Bearer ${credentials.accessToken}`,
+        };
     }
-    checkEmail(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/api/v1.0/account/check/email`;
-            const result = yield axios.post(url, { email }, { headers });
-            const data = result.data;
-            // Privo's email API returns invalid profanity information.
-            const schema = z.object({
-                available: z.boolean(),
-                suggestions: z.array(z.string()).optional(),
-            });
-            const validated = schema.parse(data);
-            return {
-                available: validated.available,
-                suggestions: validated.suggestions,
-            };
-        });
-    }
-    checkDisplayName(displayName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this._config.getPrivoConfiguration();
-            if (!config) {
-                throw new Error('No Privo configuration found.');
-            }
-            const headers = yield this._getRequestHeaders(config);
-            const url = `${config.gatewayEndpoint}/api/v1.0/account/check/display-name`;
-            const result = yield axios.post(url, {
-                display_name: displayName,
-                suggest: true,
-            }, { headers });
-            const data = result.data;
-            const schema = z.object({
-                available: z.boolean(),
-                suggestions: z.array(z.string()).optional(),
-                profanity: z.boolean().optional(),
-            });
-            const validated = schema.parse(data);
-            return {
-                available: validated.available,
-                profanity: validated.profanity,
-                suggestions: validated.suggestions,
-            };
-        });
-    }
-    _getRequestHeaders(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const credentials = yield this._getClientCredentials(config);
-            if (!credentials) {
-                throw new Error('No Privo credentials found.');
-            }
-            return {
-                Authorization: `Bearer ${credentials.accessToken}`,
-            };
-        });
-    }
-    _getClientCredentials(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const creds = yield this._store.getStoredCredentials();
-            if (creds) {
-                const expired = creds.expiresAtSeconds < Date.now() / 1000;
-                if (!expired) {
-                    return creds;
-                }
-                else {
-                    const tokens = yield this._openid.refresh(creds.refreshToken);
-                    return this._saveTokenSet(tokens);
-                }
+    async _getClientCredentials(config) {
+        const creds = await this._store.getStoredCredentials();
+        if (creds) {
+            const expired = creds.expiresAtSeconds < Date.now() / 1000;
+            if (!expired) {
+                return creds;
             }
             else {
-                const tokens = yield this._openid.grant({
-                    grant_type: 'client_credentials',
-                    scope: config.clientTokenScopes,
-                });
+                const tokens = await this._openid.refresh(creds.refreshToken);
                 return this._saveTokenSet(tokens);
             }
-        });
+        }
+        else {
+            const tokens = await this._openid.grant({
+                grant_type: 'client_credentials',
+                scope: config.clientTokenScopes,
+            });
+            return this._saveTokenSet(tokens);
+        }
     }
-    _saveTokenSet(set) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const creds = {
-                id: uuid(),
-                accessToken: set.access_token,
-                expiresAtSeconds: set.expires_at,
-                refreshToken: set.refresh_token,
-                scope: set.scope,
-            };
-            yield this._store.saveCredentials(creds);
-            return creds;
-        });
+    async _saveTokenSet(set) {
+        const creds = {
+            id: uuid(),
+            accessToken: set.access_token,
+            expiresAtSeconds: set.expires_at,
+            refreshToken: set.refresh_token,
+            scope: set.scope,
+        };
+        await this._store.saveCredentials(creds);
+        return creds;
     }
 }
 __decorate([