auth0-deploy-cli 8.22.0 → 8.23.1

package/lib/tools/auth0/handlers/guardianFactorProviders.js

@@ -1,24 +1,4 @@
 "use strict";
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -46,76 +26,73 @@ exports.schema = {
 };
 class GuardianFactorProvidersHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'guardianFactorProviders', id: 'name' }));
-    }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            try {
-                const data = yield Promise.all(mappings.map((m) => __awaiter(this, void 0, void 0, function* () {
-                    let provider;
-                    // TODO: This is quite a change, needs to be validated for sure.
-                    if (m.name === 'phone' && m.provider === 'twilio') {
-                        provider = yield this.client.guardian.getPhoneFactorProviderTwilio();
-                    }
-                    else if (m.name === 'sms' && m.provider === 'twilio') {
-                        provider = yield this.client.guardian.getSmsFactorProviderTwilio();
-                    }
-                    else if (m.name === 'push-notification' && m.provider === 'apns') {
-                        provider = yield this.client.guardian.getPushNotificationProviderAPNS();
-                    }
-                    else if (m.name === 'push-notification' && m.provider === 'sns') {
-                        provider = yield this.client.guardian.getPushNotificationProviderSNS();
-                    }
-                    return Object.assign(Object.assign({}, m), provider.data);
-                })));
-                // Filter out empty, should have more then 2 keys (name, provider)
-                return data.filter((d) => Object.keys(d).length > 2);
-            }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return null;
-                }
-                if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
-                    return null;
-                }
-                throw err;
-            }
+        super({
+            ...options,
+            type: 'guardianFactorProviders',
+            id: 'name',
         });
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create guardianFactorProviders, we can only update.
-            const { guardianFactorProviders } = assets;
-            // Do nothing if not set
-            if (!guardianFactorProviders || !guardianFactorProviders.length)
-                return;
-            // Process each factor
-            yield Promise.all(guardianFactorProviders.map((factorProvider) => __awaiter(this, void 0, void 0, function* () {
-                const { name, provider } = factorProvider, data = __rest(factorProvider, ["name", "provider"]);
-                const params = { name: factorProvider.name, provider: factorProvider.provider };
-                // TODO: This is quite a change, needs to be validated for sure.
-                if (name === 'phone' && provider === 'twilio') {
-                    yield this.client.guardian.updatePhoneFactorProviderTwilio(data);
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        try {
+            const data = await Promise.all(mappings.map(async (m) => {
+                let provider;
+                if (m.name === 'phone' && m.provider === 'twilio') {
+                    provider = await this.client.guardian.factors.phone.getTwilioProvider();
                 }
-                else if (name === 'sms' && provider === 'twilio') {
-                    yield this.client.guardian.setSmsFactorProviderTwilio(data);
+                else if (m.name === 'sms' && m.provider === 'twilio') {
+                    provider = await this.client.guardian.factors.sms.getTwilioProvider();
                 }
-                else if (name === 'push-notification' && provider === 'apns') {
-                    yield this.client.guardian.updatePushNotificationProviderAPNS(data);
+                else if (m.name === 'push-notification' && m.provider === 'apns') {
+                    provider = await this.client.guardian.factors.pushNotification.getApnsProvider();
                 }
-                else if (name === 'push-notification' && provider === 'fcm') {
-                    yield this.client.guardian.updatePushNotificationProviderFCM(data);
+                else if (m.name === 'push-notification' && m.provider === 'sns') {
+                    provider = await this.client.guardian.factors.pushNotification.getSnsProvider();
                 }
-                else if (name === 'push-notification' && provider === 'sns') {
-                    yield this.client.guardian.updatePushNotificationProviderSNS(data);
-                }
-                this.didUpdate(params);
-                this.updated += 1;
-            })));
-        });
+                return { ...m, ...provider.data };
+            }));
+            // Filter out empty, should have more then 2 keys (name, provider)
+            return data.filter((d) => Object.keys(d).length > 2);
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
+                return null;
+            }
+            if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async processChanges(assets) {
+        // No API to delete or create guardianFactorProviders, we can only update.
+        const { guardianFactorProviders } = assets;
+        // Do nothing if not set
+        if (!guardianFactorProviders || !guardianFactorProviders.length)
+            return;
+        // Process each factor
+        await Promise.all(guardianFactorProviders.map(async (factorProvider) => {
+            const { name, provider, ...data } = factorProvider;
+            const params = { name: factorProvider.name, provider: factorProvider.provider };
+            if (name === 'phone' && provider === 'twilio') {
+                await this.client.guardian.factors.phone.setTwilioProvider(data);
+            }
+            else if (name === 'sms' && provider === 'twilio') {
+                await this.client.guardian.factors.sms.setTwilioProvider(data);
+            }
+            else if (name === 'push-notification' && provider === 'apns') {
+                await this.client.guardian.factors.pushNotification.setApnsProvider(data);
+            }
+            else if (name === 'push-notification' && provider === 'fcm') {
+                await this.client.guardian.factors.pushNotification.setFcmProvider(data);
+            }
+            else if (name === 'push-notification' && provider === 'sns') {
+                await this.client.guardian.factors.pushNotification.setSnsProvider(data);
+            }
+            this.didUpdate(params);
+            this.updated += 1;
+        }));
     }
 }
 exports.default = GuardianFactorProvidersHandler;
-//# sourceMappingURL=guardianFactorProviders.js.map

package/lib/tools/auth0/handlers/guardianFactorTemplates.js

@@ -1,24 +1,4 @@
 "use strict";
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -39,58 +19,56 @@ exports.schema = {
 };
 class GuardianFactorTemplatesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'guardianFactorTemplates', id: 'name' }));
-    }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            try {
-                const data = yield Promise.all(constants_1.default.GUARDIAN_FACTOR_TEMPLATES.map((name) => __awaiter(this, void 0, void 0, function* () {
-                    if (name === 'sms') {
-                        const { data: templates } = yield this.client.guardian.getSmsFactorTemplates();
-                        return Object.assign({ name }, templates);
-                    }
-                    const { data: templates } = yield this.client.guardian.getPhoneFactorTemplates();
-                    return Object.assign({ name }, templates);
-                })));
-                // Filter out empty, should have more then 1 keys (name)
-                return data.filter((d) => Object.keys(d).length > 1);
-            }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return null;
-                }
-                if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
-                    return null;
-                }
-                throw err;
-            }
+        super({
+            ...options,
+            type: 'guardianFactorTemplates',
+            id: 'name',
         });
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create guardianFactorTemplates, we can only update.
-            const { guardianFactorTemplates } = assets;
-            // Do nothing if not set
-            if (!guardianFactorTemplates || !guardianFactorTemplates.length)
-                return;
-            // Process each factor templates
-            yield Promise.all(guardianFactorTemplates.map((fatorTemplates) => __awaiter(this, void 0, void 0, function* () {
-                const { name } = fatorTemplates, data = __rest(fatorTemplates, ["name"]);
-                const params = { name: fatorTemplates.name };
-                // TODO: This is quite a change, needs to be validated for sure.
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        try {
+            const data = await Promise.all(constants_1.default.GUARDIAN_FACTOR_TEMPLATES.map(async (name) => {
                 if (name === 'sms') {
-                    yield this.client.guardian.setSmsFactorTemplates(data);
-                }
-                else if (name === 'phone') {
-                    yield this.client.guardian.setPhoneFactorTemplates(data);
+                    const templates = await this.client.guardian.factors.sms.getTemplates();
+                    return { name, ...templates };
                 }
-                this.didUpdate(params);
-                this.updated += 1;
-            })));
-        });
+                const templates = await this.client.guardian.factors.phone.getTemplates();
+                return { name, ...templates };
+            }));
+            // Filter out empty, should have more then 1 keys (name)
+            return data.filter((d) => Object.keys(d).length > 1);
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
+                return null;
+            }
+            if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async processChanges(assets) {
+        // No API to delete or create guardianFactorTemplates, we can only update.
+        const { guardianFactorTemplates } = assets;
+        // Do nothing if not set
+        if (!guardianFactorTemplates || !guardianFactorTemplates.length)
+            return;
+        // Process each factor templates
+        await Promise.all(guardianFactorTemplates.map(async (fatorTemplates) => {
+            const { name, ...data } = fatorTemplates;
+            const params = { name: fatorTemplates.name };
+            if (name === 'sms') {
+                await this.client.guardian.factors.sms.setTemplates(data);
+            }
+            else if (name === 'phone') {
+                await this.client.guardian.factors.phone.setTemplates(data);
+            }
+            this.didUpdate(params);
+            this.updated += 1;
+        }));
     }
 }
 exports.default = GuardianFactorTemplatesHandler;
-//# sourceMappingURL=guardianFactorTemplates.js.map

package/lib/tools/auth0/handlers/guardianFactors.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -28,46 +19,45 @@ exports.schema = {
 };
 class GuardianFactorsHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'guardianFactors', id: 'name' }));
+        super({
+            ...options,
+            type: 'guardianFactors',
+            id: 'name',
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            try {
-                const { data } = yield this.client.guardian.getFactors();
-                this.existing = data;
-                return this.existing;
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        try {
+            const factors = await this.client.guardian.factors.list();
+            this.existing = factors;
+            return this.existing;
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
+                return null;
             }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return null;
-                }
-                if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
-                    return null;
-                }
-                throw err;
+            if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
+                return null;
             }
-        });
+            throw err;
+        }
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create guardianFactors, we can only update.
-            const { guardianFactors } = assets;
-            // Do nothing if not set
-            if (!guardianFactors || !guardianFactors.length)
-                return;
-            // Process each factor
-            yield Promise.all(guardianFactors.map((factor) => __awaiter(this, void 0, void 0, function* () {
-                const data = Object.assign({}, factor);
-                const params = { name: factor.name };
-                delete data.name;
-                yield this.client.guardian.updateFactor(params, data);
-                this.didUpdate(params);
-                this.updated += 1;
-            })));
-        });
+    async processChanges(assets) {
+        // No API to delete or create guardianFactors, we can only update.
+        const { guardianFactors } = assets;
+        // Do nothing if not set
+        if (!guardianFactors || !guardianFactors.length)
+            return;
+        // Process each factor
+        await Promise.all(guardianFactors.map(async (factor) => {
+            const data = { ...factor };
+            const params = { name: factor.name };
+            delete data.name;
+            await this.client.guardian.factors.set(params.name, data);
+            this.didUpdate(params);
+            this.updated += 1;
+        }));
     }
 }
 exports.default = GuardianFactorsHandler;
-//# sourceMappingURL=guardianFactors.js.map

package/lib/tools/auth0/handlers/guardianPhoneFactorMessageTypes.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -46,47 +37,40 @@ const isFeatureUnavailableError = (err) => {
 };
 class GuardianPhoneMessageTypesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'guardianPhoneFactorMessageTypes' }));
+        super({
+            ...options,
+            type: 'guardianPhoneFactorMessageTypes',
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // in case client version does not support the operation
-            if (!this.client.guardian ||
-                typeof this.client.guardian.getPhoneFactorMessageTypes !== 'function') {
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        try {
+            const data = await this.client.guardian.factors.phone.getMessageTypes();
+            this.existing = data;
+        }
+        catch (err) {
+            if (isFeatureUnavailableError(err)) {
+                // Gracefully skip processing this configuration value.
                 return null;
             }
-            if (this.existing)
-                return this.existing;
-            try {
-                const { data } = yield this.client.guardian.getPhoneFactorMessageTypes();
-                this.existing = data;
-            }
-            catch (err) {
-                if (isFeatureUnavailableError(err)) {
-                    // Gracefully skip processing this configuration value.
-                    return null;
-                }
-                if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
-                    return null;
-                }
-                throw err;
+            if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
+                return null;
             }
-            return this.existing;
-        });
+            throw err;
+        }
+        return this.existing;
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create guardianPhoneFactorMessageTypes, we can only update.
-            const { guardianPhoneFactorMessageTypes } = assets;
-            // Do nothing if not set
-            if (!guardianPhoneFactorMessageTypes || !guardianPhoneFactorMessageTypes.message_types)
-                return;
-            const data = guardianPhoneFactorMessageTypes;
-            yield this.client.guardian.updatePhoneFactorMessageTypes(data);
-            this.updated += 1;
-            this.didUpdate(guardianPhoneFactorMessageTypes);
-        });
+    async processChanges(assets) {
+        // No API to delete or create guardianPhoneFactorMessageTypes, we can only update.
+        const { guardianPhoneFactorMessageTypes } = assets;
+        // Do nothing if not set
+        if (!guardianPhoneFactorMessageTypes || !guardianPhoneFactorMessageTypes.message_types)
+            return;
+        const data = guardianPhoneFactorMessageTypes;
+        await this.client.guardian.factors.phone.setMessageTypes(data);
+        this.updated += 1;
+        this.didUpdate(guardianPhoneFactorMessageTypes);
     }
 }
 exports.default = GuardianPhoneMessageTypesHandler;
-//# sourceMappingURL=guardianPhoneFactorMessageTypes.js.map

package/lib/tools/auth0/handlers/guardianPhoneFactorSelectedProvider.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -43,47 +34,40 @@ const isFeatureUnavailableError = (err) => {
 };
 class GuardianPhoneSelectedProviderHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'guardianPhoneFactorSelectedProvider' }));
+        super({
+            ...options,
+            type: 'guardianPhoneFactorSelectedProvider',
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // in case client version does not support the operation
-            if (!this.client.guardian ||
-                typeof this.client.guardian.getPhoneFactorSelectedProvider !== 'function') {
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        try {
+            const data = await this.client.guardian.factors.phone.getSelectedProvider();
+            this.existing = data;
+        }
+        catch (err) {
+            if (isFeatureUnavailableError(err)) {
+                // Gracefully skip processing this configuration value.
                 return null;
             }
-            if (this.existing)
-                return this.existing;
-            try {
-                const { data } = yield this.client.guardian.getPhoneFactorSelectedProvider();
-                this.existing = data;
-            }
-            catch (err) {
-                if (isFeatureUnavailableError(err)) {
-                    // Gracefully skip processing this configuration value.
-                    return null;
-                }
-                if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
-                    return null;
-                }
-                throw err;
+            if ((0, utils_1.isForbiddenFeatureError)(err, this.type)) {
+                return null;
             }
-            return this.existing;
-        });
+            throw err;
+        }
+        return this.existing;
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create guardianPhoneFactorSelectedProvider, we can only update.
-            const { guardianPhoneFactorSelectedProvider } = assets;
-            // Do nothing if not set
-            if (!guardianPhoneFactorSelectedProvider || !guardianPhoneFactorSelectedProvider.provider)
-                return;
-            const data = guardianPhoneFactorSelectedProvider;
-            yield this.client.guardian.updatePhoneFactorSelectedProvider(data);
-            this.updated += 1;
-            this.didUpdate(guardianPhoneFactorSelectedProvider);
-        });
+    async processChanges(assets) {
+        // No API to delete or create guardianPhoneFactorSelectedProvider, we can only update.
+        const { guardianPhoneFactorSelectedProvider } = assets;
+        // Do nothing if not set
+        if (!guardianPhoneFactorSelectedProvider || !guardianPhoneFactorSelectedProvider.provider)
+            return;
+        const data = guardianPhoneFactorSelectedProvider;
+        await this.client.guardian.factors.phone.setProvider(data);
+        this.updated += 1;
+        this.didUpdate(guardianPhoneFactorSelectedProvider);
     }
 }
 exports.default = GuardianPhoneSelectedProviderHandler;
-//# sourceMappingURL=guardianPhoneFactorSelectedProvider.js.map

package/lib/tools/auth0/handlers/guardianPolicies.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,35 +21,29 @@ exports.schema = {
 };
 class GuardianPoliciesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'guardianPolicies' }));
+        super({
+            ...options,
+            type: 'guardianPolicies',
+        });
     }
-    //TODO: standardize empty object literal with more intentional empty indicator
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // in case client version does not support the operation
-            if (!this.client.guardian || typeof this.client.guardian.getPolicies !== 'function') {
-                return {};
-            }
-            if (this.existing)
-                return this.existing;
-            const { data: policies } = yield this.client.guardian.getPolicies();
-            this.existing = { policies };
+    // TODO: standardize empty object literal with more intentional empty indicator
+    async getType() {
+        if (this.existing)
             return this.existing;
-        });
+        const policies = await this.client.guardian.policies.list();
+        this.existing = { policies };
+        return this.existing;
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create guardianPolicies, we can only update.
-            const { guardianPolicies } = assets;
-            // Do nothing if not set
-            if (!guardianPolicies || !guardianPolicies.policies)
-                return;
-            const data = guardianPolicies.policies;
-            yield this.client.guardian.updatePolicies(data);
-            this.updated += 1;
-            this.didUpdate(guardianPolicies);
-        });
+    async processChanges(assets) {
+        // No API to delete or create guardianPolicies, we can only update.
+        const { guardianPolicies } = assets;
+        // Do nothing if not set
+        if (!guardianPolicies || !guardianPolicies.policies)
+            return;
+        const data = guardianPolicies.policies;
+        await this.client.guardian.policies.set(data);
+        this.updated += 1;
+        this.didUpdate(guardianPolicies);
     }
 }
 exports.default = GuardianPoliciesHandler;
-//# sourceMappingURL=guardianPolicies.js.map