addigy 2.8.2 → 2.10.0

package/lib/files/files.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Files = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class Files {
+    constructor(config) {
+        this.config = config;
+        this.http = axios_1.default.create({
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+        });
+    }
+    async getFileUploadUrl(fileName, contentType) {
+        const headers = {
+            'client-Id': this.config.clientId,
+            'client-Secret': this.config.clientSecret,
+            'file-name': fileName,
+            'content-type': contentType !== null && contentType !== void 0 ? contentType : 'application/octet-stream',
+        };
+        try {
+            let res = await this.http.get(`${addigy_constants_1.Urls.fileManager}/api/upload/url`, {
+                headers,
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async uploadFile(uploadUrl, file, contentType) {
+        const headers = {
+            'content-type': contentType !== null && contentType !== void 0 ? contentType : 'application/octet-stream',
+        };
+        try {
+            let res = await this.http.put(uploadUrl, file, {
+                headers,
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async getFileVaultKeys(authObject) {
+        try {
+            let res = await this.http.get(`${addigy_constants_1.Urls.api}/get_org_filevault_keys`, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                    origin: addigy_constants_1.Urls.appProd,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Files = Files;

package/lib/files/files.types.d.ts

@@ -0,0 +1,26 @@
+import { Payload } from '../types';
+export interface FilevaultPayload extends Payload {
+    enable?: 'On' | 'Off';
+    defer?: boolean;
+    use_recovery_key?: boolean;
+    show_recovery_key?: boolean | null;
+    defer_dont_ask_at_user_logout?: boolean | null;
+    defer_force_at_user_login_max_bypass_attempts?: number | null;
+    addigy_payload_version?: number;
+    destroy_fv_key_on_standby?: boolean | null;
+    dont_allow_fde_disable?: boolean;
+    is_from_security_profile?: boolean;
+    encrypt_cert_payload_uuid?: string;
+    location?: string;
+    payload_priority?: number;
+    redirect_url?: string;
+}
+export interface FilevaultRequest {
+    enable?: boolean;
+    defer?: boolean;
+    showRecoveryKey?: boolean;
+    destroyFvKeyOnStandby?: boolean;
+    escrowRecoveryKey?: boolean;
+    deferDontAskAtUserLogout?: boolean;
+    deferForceAtUserLoginMaxBypassAttempts?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+}

package/lib/files/files.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/integrations/integrations.d.ts

@@ -0,0 +1,8 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+export declare class Integrations {
+    private readonly headers;
+    private readonly http;
+    getApiIntegrations(authObject: IAddigyInternalAuthObject): Promise<object[]>;
+    createApiIntegration(authObject: IAddigyInternalAuthObject, name: string): Promise<object>;
+    deleteApiIntegration(authObject: IAddigyInternalAuthObject, objectId: string): Promise<object>;
+}

package/lib/integrations/integrations.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Integrations = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class Integrations {
+    constructor() {
+        this.headers = { origin: addigy_constants_1.Urls.appProd };
+        this.http = axios_1.default.create({
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+            headers: this.headers,
+        });
+    }
+    async getApiIntegrations(authObject) {
+        try {
+            let res = await this.http.get(`${addigy_constants_1.Urls.api}/accounts/api/keys/get`, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                    email: authObject.emailAddress,
+                    orgid: authObject.orgId,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async createApiIntegration(authObject, name) {
+        let postBody = {
+            name,
+        };
+        try {
+            let res = await this.http.post(`${addigy_constants_1.Urls.appProd}/api/integrations/keys`, postBody, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async deleteApiIntegration(authObject, objectId) {
+        try {
+            let res = await this.http.delete(`${addigy_constants_1.Urls.appProd}/api/integrations/keys?id=${objectId}`, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Integrations = Integrations;

package/lib/maintenance/maintenance.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from 'axios';
+export declare class Maintenance {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    getMaintenance(page?: number, pageLength?: number): Promise<object[]>;
+}

package/lib/maintenance/maintenance.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Maintenance = void 0;
+class Maintenance {
+    constructor(http) {
+        this.http = http;
+    }
+    async getMaintenance(page = 1, pageLength = 10) {
+        try {
+            let res = await this.http.get(`maintenance?page=${page}&per_page=${pageLength}`);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Maintenance = Maintenance;

package/lib/mdm/mdm-configurations.d.ts

@@ -0,0 +1,7 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+import { MdmConfigurationPayload } from './mdm.types';
+export declare class MdmConfigurations {
+    private readonly http;
+    getMdmConfigurations(authObject: IAddigyInternalAuthObject): Promise<MdmConfigurationPayload[]>;
+    getMdmConfigurationByName(authObject: IAddigyInternalAuthObject, name: string): Promise<MdmConfigurationPayload | undefined>;
+}

package/lib/mdm/mdm-configurations.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdmConfigurations = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class MdmConfigurations {
+    constructor() {
+        this.http = axios_1.default.create({
+            baseURL: `${addigy_constants_1.Urls.app}/api/v2/mdm`,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+        });
+    }
+    async getMdmConfigurations(authObject) {
+        var _a;
+        try {
+            let res = await this.http.get('configurations/profiles', {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return (_a = res.data) === null || _a === void 0 ? void 0 : _a.payloads;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async getMdmConfigurationByName(authObject, name) {
+        try {
+            const mdmConfigurations = await this.getMdmConfigurations(authObject);
+            return mdmConfigurations.find((e) => e.payload_display_name === name);
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.MdmConfigurations = MdmConfigurations;

package/lib/mdm/mdm-policies.d.ts

@@ -0,0 +1,20 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+import { CreateWebContentFilterPayload, Extension, NotificationSettings, PPPCInput, ServiceManagementPayloadRule } from './mdm.types';
+import { FilevaultRequest } from '../files/files.types';
+export declare class MdmPolicies {
+    private readonly http;
+    createKernelExtensionPolicy(authObject: IAddigyInternalAuthObject, name: string, allowOverrides: boolean, kernelExtensions: {
+        allowedTeamIdentifiers?: string[];
+        allowedKernelExtensions?: Extension[];
+    }): Promise<any>;
+    createSystemExtensionPolicy(authObject: IAddigyInternalAuthObject, name: string, allowOverrides: boolean, systemExtensions: {
+        allowedSystemExtensions?: Extension[];
+        allowedSystemExtensionTypes?: Extension[];
+        allowedTeamIdentifiers?: string[];
+    }): Promise<any>;
+    createNotificationSettingsPolicy(authObject: IAddigyInternalAuthObject, name: string, notificationSettings: NotificationSettings[]): Promise<any>;
+    createServiceManagementPolicy(authObject: IAddigyInternalAuthObject, name: string, rules: ServiceManagementPayloadRule[], priority?: number): Promise<any>;
+    createWebContentFilterPolicy(authObject: IAddigyInternalAuthObject, payloadName: string, webContentPayload: CreateWebContentFilterPayload, priority?: number): Promise<any>;
+    createFilevaultPolicy(authObject: IAddigyInternalAuthObject, name: string, filevault: FilevaultRequest, payloadPriority?: number): Promise<any>;
+    createPPPCPolicy(authObject: IAddigyInternalAuthObject, name: string, pppcPolicy: PPPCInput[]): Promise<any>;
+}

package/lib/mdm/mdm-policies.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdmPolicies = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const uuid_1 = require("uuid");
+const addigy_utils_1 = require("../addigy.utils");
+class MdmPolicies {
+    constructor() {
+        this.http = axios_1.default.create({
+            baseURL: `${addigy_constants_1.Urls.appProd}/api/mdm/user/profiles/configurations`,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+            headers: { origin: addigy_constants_1.Urls.appProd },
+        });
+    }
+    async createKernelExtensionPolicy(authObject, name, allowOverrides, kernelExtensions) {
+        var _a, _b;
+        let payloadUUID = (0, uuid_1.v4)();
+        let groupUUID = (0, uuid_1.v4)();
+        const payload = {
+            addigy_payload_type: 'com.addigy.syspolicy.kernel-extension-policy.com.apple.syspolicy.kernel-extension-policy',
+            payload_type: 'com.apple.syspolicy.kernel-extension-policy',
+            payload_version: 1,
+            payload_identifier: `com.addigy.syspolicy.kernel-extension-policy.com.apple.syspolicy.kernel-extension-policy.${groupUUID}`,
+            payload_uuid: payloadUUID,
+            payload_group_id: groupUUID,
+            payload_enabled: true,
+            payload_display_name: name,
+            allow_user_overrides: allowOverrides,
+            allowed_kernel_extensions: {},
+            allowed_team_identifiers: [],
+        };
+        if ((_a = kernelExtensions.allowedKernelExtensions) === null || _a === void 0 ? void 0 : _a.length) {
+            kernelExtensions.allowedKernelExtensions.forEach((e) => {
+                payload.allowed_kernel_extensions[e.teamIdentifier] = e.bundleIdentifiers;
+            });
+        }
+        if ((_b = kernelExtensions.allowedTeamIdentifiers) === null || _b === void 0 ? void 0 : _b.length) {
+            kernelExtensions.allowedTeamIdentifiers.forEach((e) => {
+                payload.allowed_team_identifiers.push(e);
+            });
+        }
+        try {
+            let res = await this.http.post('/', { payloads: [payload] }, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async createSystemExtensionPolicy(authObject, name, allowOverrides, systemExtensions) {
+        var _a, _b, _c;
+        const groupUUID = (0, uuid_1.v4)();
+        const payload = {
+            addigy_payload_type: 'com.addigy.syspolicy.system-extension-policy.com.apple.system-extension-policy',
+            payload_type: 'com.apple.system-extension-policy',
+            payload_version: 1,
+            payload_identifier: `com.addigy.syspolicy.system-extension-policy.com.apple.system-extension-policy.${groupUUID}`,
+            payload_uuid: (0, uuid_1.v4)(),
+            payload_group_id: groupUUID,
+            payload_enabled: true,
+            payload_display_name: name,
+            allowed_system_extensions: {},
+            allowed_system_extensions_types: {},
+            allowed_team_identifiers: [],
+            allow_user_overrides: allowOverrides,
+        };
+        if ((_a = systemExtensions.allowedSystemExtensions) === null || _a === void 0 ? void 0 : _a.length) {
+            systemExtensions.allowedSystemExtensions.forEach((e) => {
+                payload.allowed_system_extensions[e.teamIdentifier] = e.bundleIdentifiers;
+            });
+        }
+        if ((_b = systemExtensions.allowedSystemExtensionTypes) === null || _b === void 0 ? void 0 : _b.length) {
+            systemExtensions.allowedSystemExtensionTypes.forEach((e) => {
+                payload.allowed_system_extensions_types[e.teamIdentifier] = e.bundleIdentifiers;
+            });
+        }
+        if ((_c = systemExtensions.allowedTeamIdentifiers) === null || _c === void 0 ? void 0 : _c.length) {
+            systemExtensions.allowedTeamIdentifiers.forEach((e) => {
+                payload.allowed_team_identifiers.push(e);
+            });
+        }
+        try {
+            let res = await this.http.post('/', { payloads: [payload] }, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async createNotificationSettingsPolicy(authObject, name, notificationSettings) {
+        const groupUUID = (0, uuid_1.v4)();
+        const payload = {
+            addigy_payload_type: 'com.addigy.notifications.com.apple.notificationsettings',
+            payload_type: 'com.apple.notificationsettings',
+            payload_version: 1,
+            payload_identifier: `com.addigy.notifications.com.apple.notificationsettings.${groupUUID}`,
+            payload_uuid: (0, uuid_1.v4)(),
+            payload_group_id: groupUUID,
+            payload_display_name: name,
+            notification_settings: notificationSettings,
+        };
+        let res = await this.http.post('/', { payloads: [payload] }, {
+            headers: {
+                Cookie: `auth_token=${authObject.authToken};`,
+            },
+        });
+        return res.data;
+    }
+    async createServiceManagementPolicy(authObject, name, rules, priority = 9) {
+        const groupUUID = (0, uuid_1.v4)();
+        const payload = {
+            addigy_payload_type: 'com.addigy.servicemanagement.com.apple.servicemanagement',
+            addigy_payload_version: 0,
+            has_manifest: false,
+            payload_display_name: name,
+            payload_enabled: false,
+            payload_group_id: groupUUID,
+            payload_identifier: `com.addigy.servicemanagement.com.apple.servicemanagement.${groupUUID}`,
+            payload_priority: priority,
+            payload_type: 'com.apple.servicemanagement',
+            payload_uuid: (0, uuid_1.v4)(),
+            payload_version: 1,
+            policy_restricted: false,
+            requires_device_supervision: false,
+            requires_mdm_profile_approved: false,
+            supported_os_versions: null,
+            rules,
+        };
+        try {
+            let res = await this.http.post('/', { payloads: [payload] }, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async createWebContentFilterPolicy(authObject, payloadName, webContentPayload, priority = 9) {
+        const groupUUID = (0, uuid_1.v4)();
+        const payload = {
+            addigy_payload_type: 'com.addigy.webcontent-filter.com.apple.webcontent-filter',
+            addigy_payload_version: 2,
+            auto_filter_enabled: null,
+            blacklisted_urls: null,
+            content_filter_uuid: null,
+            filter_browsers: null,
+            filter_data_provider_bundle_identifier: null,
+            filter_data_provider_designated_requirement: null,
+            filter_packet_provider_bundle_identifier: null,
+            filter_packet_provider_designated_requirement: null,
+            filter_packets: null,
+            filter_sockets: true,
+            filter_type: 'Plugin',
+            has_manifest: false,
+            organization: null,
+            password: null,
+            payload_display_name: payloadName,
+            payload_enabled: true,
+            payload_group_id: groupUUID,
+            payload_identifier: `com.addigy.webcontent-filter.com.apple.webcontent-filter.${groupUUID}`,
+            payload_priority: priority,
+            payload_type: 'com.apple.webcontent-filter',
+            payload_uuid: (0, uuid_1.v4)(),
+            payload_version: 1,
+            permitted_urls: null,
+            policy_restricted: false,
+            requires_device_supervision: false,
+            requires_mdm_profile_approved: false,
+            server_address: null,
+            supported_os_versions: null,
+            user_name: null,
+            vendor_config: null,
+            white_listed_bookmarks: null,
+            ...webContentPayload,
+        };
+        let res = await this.http.post('/', { payloads: [payload] }, {
+            headers: {
+                Cookie: `auth_token=${authObject.authToken};`,
+            },
+        });
+        return res.data;
+    }
+    async createFilevaultPolicy(authObject, name, filevault, payloadPriority = 1) {
+        const groupUUID = (0, uuid_1.v4)();
+        const encryptCertPayloadUUID = (0, uuid_1.v4)();
+        const basePayload = {
+            payload_display_name: name,
+            payload_version: 1,
+            payload_group_id: groupUUID,
+            addigy_payload_version: 0,
+            payload_priority: payloadPriority,
+        };
+        const payloads = [
+            {
+                ...basePayload,
+                payload_type: 'com.apple.MCX.FileVault2',
+                addigy_payload_type: 'com.addigy.securityAndPrivacy.com.apple.MCX.FileVault2',
+                payload_identifier: `com.addigy.securityAndPrivacy.com.apple.MCX.FileVault2.${groupUUID}`,
+                payload_uuid: (0, uuid_1.v4)(),
+                enable: filevault.enable ? 'On' : 'Off',
+                defer: filevault.defer,
+                use_recovery_key: true,
+                show_recovery_key: filevault.showRecoveryKey === undefined ? null : filevault.showRecoveryKey,
+                defer_dont_ask_at_user_logout: filevault.deferDontAskAtUserLogout === undefined
+                    ? null
+                    : filevault.deferDontAskAtUserLogout,
+                defer_force_at_user_login_max_bypass_attempts: filevault.deferForceAtUserLoginMaxBypassAttempts === undefined
+                    ? null
+                    : filevault.deferForceAtUserLoginMaxBypassAttempts,
+            },
+            {
+                ...basePayload,
+                payload_type: 'com.apple.MCX',
+                addigy_payload_type: 'com.addigy.securityAndPrivacy.com.apple.MCX',
+                payload_identifier: `com.addigy.securityAndPrivacy.com.apple.MCX.${groupUUID} `,
+                payload_uuid: (0, uuid_1.v4)(),
+                destroy_fv_key_on_standby: filevault.destroyFvKeyOnStandby === undefined
+                    ? null
+                    : filevault.destroyFvKeyOnStandby,
+                dont_allow_fde_disable: true,
+            },
+        ];
+        if (filevault.escrowRecoveryKey)
+            payloads.push({
+                ...basePayload,
+                addigy_payload_type: 'com.addigy.securityAndPrivacy.com.apple.security.pkcs1',
+                payload_type: 'com.apple.security.pkcs1',
+                payload_identifier: `com.addigy.securityAndPrivacy.com.apple.security.pkcs1.${groupUUID}`,
+                payload_uuid: (0, uuid_1.v4)(),
+                is_from_security_profile: true,
+            }, {
+                ...basePayload,
+                addigy_payload_type: 'com.addigy.securityAndPrivacy.com.apple.security.FDERecoveryKeyEscrow',
+                payload_type: 'com.apple.security.FDERecoveryKeyEscrow',
+                payload_identifier: `com.addigy.securityAndPrivacy.com.apple.security.FDERecoveryKeyEscrow.${groupUUID}`,
+                payload_uuid: (0, uuid_1.v4)(),
+                encrypt_cert_payload_uuid: encryptCertPayloadUUID,
+                location: 'Key will be escrowed to an Addigy secure database.',
+            }, {
+                ...basePayload,
+                addigy_payload_type: 'com.addigy.securityAndPrivacy.com.apple.security.FDERecoveryRedirect',
+                payload_type: 'com.apple.security.FDERecoveryRedirect',
+                payload_identifier: `com.addigy.securityAndPrivacy.com.apple.security.FDERecoveryRedirect.${groupUUID}`,
+                payload_uuid: (0, uuid_1.v4)(),
+                encrypt_cert_payload_uuid: encryptCertPayloadUUID,
+                redirect_url: '',
+            });
+        try {
+            let res = await this.http.post('/', { payloads }, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async createPPPCPolicy(authObject, name, pppcPolicy) {
+        const groupUUID = (0, uuid_1.v4)();
+        const payload = {
+            addigy_payload_type: 'com.addigy.TCC.configuration-profile-policy.com.apple.TCC.configuration-profile-policy',
+            payload_type: 'com.apple.TCC.configuration-profile-policy',
+            payload_display_name: name,
+            payload_group_id: groupUUID,
+            payload_version: 1,
+            payload_identifier: `com.addigy.TCC.configuration-profile-policy.com.apple.TCC.configuration-profile-policy.${groupUUID}`,
+            payload_uuid: (0, uuid_1.v4)(),
+            services: {
+                accessibility: [],
+                address_book: [],
+                apple_events: [],
+                calendar: [],
+                camera: [],
+                microphone: [],
+                photos: [],
+                post_event: [],
+                reminders: [],
+                system_policy_all_files: [],
+                system_policy_sys_admin_files: [],
+                file_provider_presence: [],
+                listen_event: [],
+                media_library: [],
+                screen_capture: [],
+                speech_recognition: [],
+                system_policy_desktop_folder: [],
+                system_policy_documents_folder: [],
+                system_policy_downloads_folder: [],
+                system_policy_network_volumes: [],
+                system_policy_removable_volumes: [],
+            },
+        };
+        pppcPolicy.forEach((pppc) => {
+            pppc.services.forEach((e) => {
+                var _a;
+                const service = {
+                    allowed: false,
+                    authorization: '',
+                    code_requirement: pppc.codeRequirement,
+                    comment: '',
+                    identifier_type: e.identifierType,
+                    identifier: pppc.identifier,
+                    static_code: (_a = e.staticCode) !== null && _a !== void 0 ? _a : false,
+                    predefined_app: null,
+                    manual_selection: true,
+                    rowId: (0, uuid_1.v4)(),
+                };
+                if (e.service === 'screen_capture' && e.authorization) {
+                    service.authorization = e.authorization;
+                }
+                if (e.service !== 'screen_capture')
+                    service.allowed = e.allowed;
+                if (e.service === 'apple_events') {
+                    service.ae_receiver_identifier = e.aeReceiverIdentifier;
+                    service.ae_receiver_identifier_type = e.aeReceiverIdentifierType;
+                    service.ae_receiver_code_requirement = e.aeReceiverCodeRequirement;
+                    service.ae_receiver_predefined_app = null;
+                    service.ae_receiver_manual_selection = true;
+                }
+                payload.services[e.service].push(service);
+            });
+        });
+        const res = await this.http.post('/', { payloads: [payload] }, {
+            headers: {
+                Cookie: `auth_token=${authObject.authToken};`,
+            },
+        });
+        return res.data;
+    }
+}
+exports.MdmPolicies = MdmPolicies;

package/lib/mdm/mdm-profiles.d.ts

@@ -0,0 +1,8 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+import { SupportedOsVersions } from '../types';
+export declare class MdmProfiles {
+    private readonly http;
+    createCustomProfile(authObject: IAddigyInternalAuthObject, name: string, customProfileText: string, supportedOsVersions: SupportedOsVersions, payloadScope?: 'System' | 'User', is_profile_signed?: boolean): Promise<any>;
+    createMdmProfile(authObject: IAddigyInternalAuthObject, mdmProfile: any): Promise<any>;
+    private toSnakeCase;
+}