c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/Client.mjs

@@ -0,0 +1,284 @@
+import { __awaiter } from "../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { FetchClient } from "./core/FetchClient.mjs";
+import { BasicAuth } from "./core/BasicAuth.mjs";
+import { BearerAuth } from "./core/BearerAuth.mjs";
+import { CookieAuth } from "./core/CookieAuth.mjs";
+import { NodeJSCookieAuth } from "./core/NodeJSCookieAuth.mjs";
+import "./core/index.mjs";
+import { Realtime } from "./realtime/Realtime.mjs";
+import "./realtime/index.mjs";
+import { EventService } from "./event/EventService.mjs";
+import { InventoryBinaryService } from "./inventory/InventoryBinaryService.mjs";
+import { InventoryService } from "./inventory/InventoryService.mjs";
+import { MeasurementService } from "./measurement/MeasurementService.mjs";
+import { AlarmService } from "./alarm/AlarmService.mjs";
+import { OperationService } from "./operation/OperationService.mjs";
+import { OperationBulkService } from "./operation/OperationBulkService.mjs";
+import { TenantService } from "./tenant/TenantService.mjs";
+import { UserService } from "./user/UserService.mjs";
+import { ApplicationService } from "./application/ApplicationService.mjs";
+import { SystemOptionsService } from "./system-options/SystemOptionsService.mjs";
+import { TenantOptionsService } from "./tenant-options/TenantOptionsService.mjs";
+import { TenantSecurityOptionsService } from "./tenant-security-options/TenantSecurityOptionsService.mjs";
+import { TenantLoginOptionsService } from "./tenant-login-options/TenantLoginOptionsService.mjs";
+import { AuditService } from "./audit/AuditService.mjs";
+import { InventoryRoleService } from "./inventory-role/InventoryRoleService.mjs";
+import { DeviceRegistrationService } from "./device-registration/DeviceRegistrationService.mjs";
+import { DeviceRegistrationBulkService } from "./device-registration/DeviceRegistrationBulkService.mjs";
+import { UserRoleService } from "./user-role/UserRoleService.mjs";
+import { UserGroupService } from "./user-group/UserGroupService.mjs";
+import { IdentityService } from "./identity/IdentityService.mjs";
+import { SmartGroupsService } from "./smart-groups/SmartGroupsService.mjs";
+import { SmartRulesService } from "./smart-rules/SmartRulesService.mjs";
+import "./services.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/Client.js
+var Client = class Client {
+	/**
+	* Authenticates the given user. Determines the tenant by itself via a call to tenant/currentTenant.
+	*
+	* **Example**
+	* ```typescript
+	*
+	* let client: Client;
+	* (async () => {
+	*  client = await Client.authenticate({
+	*    user: 'testuser',
+	*    password: 'password1337!'
+	*  }, 'https://acme.cumulocity.com');
+	*
+	*  //you have access to the client api now
+	*  const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+	* })();
+	* ```
+	*/
+	static authenticate(credentials, baseUrl) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const auth = new BasicAuth(credentials);
+			const clientCore = new FetchClient(auth, baseUrl);
+			const tenantName = yield this.getCurrentTenant(clientCore);
+			const client = new Client(auth, baseUrl);
+			client.core.tenant = tenantName;
+			return client;
+		});
+	}
+	/**
+	* Authenticates the given user via OAuth Internal. Determines the tenant by itself via a call to tenant/currentTenant.
+	* Login call goes to `/tenant/oauth/token` and the retrieved token will be added in the `Authorization` header to subsequent requests.
+	*
+	* **Example**
+	* ```typescript
+	*
+	* let client: Client;
+	* (async () => {
+	*  client = await Client.authenticateViaOAuthInternal({
+	*    user: 'testuser',
+	*    password: 'password1337!'
+	*  }, 'https://acme.cumulocity.com');
+	*
+	*  //you have access to the client api now
+	*  const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+	* })();
+	* ```
+	*/
+	static authenticateViaOAuthInternal(credentials, baseUrl) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const auth = new BearerAuth(yield this.loginViaOAuthInternal(credentials, true, baseUrl));
+			const clientCore = new FetchClient(auth, baseUrl);
+			const tenantName = credentials.tenant || (yield this.getCurrentTenant(clientCore));
+			const client = new Client(auth, baseUrl);
+			client.core.tenant = tenantName;
+			return client;
+		});
+	}
+	/**
+	* Authenticates the given user via OAuth Internal. Determines the tenant by itself via a call to tenant/currentTenant.
+	* Login call goes to `/tenant/oauth` and the retrieved token will be attached as a Cookie in browser environments to subsequent requests (using 'CookieAuth').
+	* In none browser environments (e.g. nodejs) the retrieved token will be added in the `Authorization` header to subsequent requests (using 'NodeJSCookieAuth').
+	*
+	* **Example**
+	* ```typescript
+	*
+	* let client: Client;
+	* (async () => {
+	*  client = await Client.authenticateViaOAuthInternalCookie({
+	*    user: 'testuser',
+	*    password: 'password1337!'
+	*  }, 'https://acme.cumulocity.com');
+	*
+	*  //you have access to the client api now
+	*  const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+	* })();
+	* ```
+	*/
+	static authenticateViaOAuthInternalCookie(credentials, baseUrl) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const response = yield this.loginViaOAuthInternal(credentials, false, baseUrl);
+			let auth;
+			if (typeof document === "undefined") auth = new NodeJSCookieAuth(response);
+			else auth = new CookieAuth();
+			const clientCore = new FetchClient(auth, baseUrl);
+			const tenantName = credentials.tenant || (yield this.getCurrentTenant(clientCore));
+			const client = new Client(auth, baseUrl);
+			client.core.tenant = tenantName;
+			return client;
+		});
+	}
+	/**
+	* Allows to use http to register a device on the platform.
+	*
+	* **Deprecated** Please use MQTT to bootstrap a device.
+	*/
+	static deviceBootstrap(options) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const { deviceId, timeout, baseUrl, basicAuthToken } = options;
+			let { expire } = options;
+			if (timeout && !expire) expire = Date.now() + timeout;
+			const deviceRegistration = new DeviceRegistrationService(new FetchClient(void 0, baseUrl));
+			let client;
+			try {
+				const { data } = yield deviceRegistration.bootstrap(deviceId, { basicAuthToken });
+				const { username, password, tenantId } = data;
+				client = new Client(new BasicAuth({
+					user: username,
+					tenant: tenantId,
+					password
+				}), baseUrl);
+				client.core.tenant = tenantId;
+			} catch (error) {
+				if ((!expire || Date.now() < expire) && error.res.status === 404) return Client.deviceBootstrap(Object.assign({ expire }, options));
+				else throw error;
+			}
+			return client;
+		});
+	}
+	/**
+	* Retrieves microservice credentials for the subscribed tenants
+	* using provided bootstrap credentials
+	*
+	* **Example**
+	* ```typescript
+	*
+	* (async () => {
+	*  const subscriptions = await Client.getMicroserviceSubscriptions({
+	*    tenant: process.env.C8Y_BOOTSTRAP_TENANT,
+	*    user: process.env.C8Y_BOOTSTRAP_USER,
+	*    password: process.env.C8Y_BOOTSTRAP_PASSWORD
+	*  }, process.env.C8Y_BASEURL);
+	*
+	*  const clients = subscriptions.map(subscription => new Client(new BasicAuth(subscription), process.env.C8Y_BASEURL));
+	*  // you have access to the client api now
+	*  const promiseArray = clients.map(client => client.options.tenant.detail({
+	*    category: process.env.APPLICATION_KEY,
+	*    key: 'someSetting'
+	*  }));
+	* })();
+	* ```
+	*/
+	static getMicroserviceSubscriptions(bootstrapCredentials_1, baseUrl_1) {
+		return __awaiter(this, arguments, void 0, function* (bootstrapCredentials, baseUrl, fetchOptions = {}) {
+			const { users } = yield (yield new FetchClient(new BasicAuth(bootstrapCredentials), baseUrl).fetch("/application/currentApplication/subscriptions", fetchOptions)).json();
+			return users.map(({ tenant, name, password }) => {
+				return {
+					tenant,
+					user: name,
+					password
+				};
+			});
+		});
+	}
+	static loginViaOAuthInternal(credentials_1) {
+		return __awaiter(this, arguments, void 0, function* (credentials, bearerAuth = true, baseUrl) {
+			const clientCore = new FetchClient(new BasicAuth(credentials), baseUrl);
+			let url = "/tenant/oauth";
+			if (bearerAuth) url += `/token`;
+			if (credentials.tenant) url += `?tenant_id=${credentials.tenant}`;
+			const params = new URLSearchParams({
+				grant_type: "PASSWORD",
+				username: credentials.user,
+				password: credentials.password,
+				tfa_code: credentials.tfa
+			});
+			const res = yield clientCore.fetch(url, {
+				method: "POST",
+				body: params.toString(),
+				headers: { "content-type": "application/x-www-form-urlencoded;charset=UTF-8" }
+			});
+			if (res.status !== 200) throw { res };
+			if (bearerAuth) return (yield res.json())["access_token"];
+			return res;
+		});
+	}
+	static getCurrentTenant(fetchClient) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const { data: tenant } = yield new TenantService(fetchClient).current();
+			return tenant.name;
+		});
+	}
+	/**
+	* Initializes a new Client, which allows to request data from the API. Differently
+	* to Client.authenticate([...]) it needs a tenant given and does not verify if the
+	* login is correct.
+	*
+	* **Example**
+	* ```typescript
+	*
+	* const auth = new BasicAuth({
+	*   user: 'youruser',
+	*   password: 'yourpassword',
+	*   tenant: 'acme'
+	* }); // use CookieAuth() if your platform uses oauth (only in browser!)
+	*
+	* const baseUrl = 'https://acme.cumulocity.com';
+	* const client = new Client(auth, baseUrl);
+	* (async () => {
+	*   const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+	* })();
+	* ```
+	*
+	* @param auth The Authentication strategy to use (e.g. new BasicAuth())
+	* @param baseUrl The URL to request (optional in browser, mandatory in node)
+	*/
+	constructor(auth, baseUrl) {
+		const client = new FetchClient(auth, baseUrl);
+		this.realtime = new Realtime(client);
+		this.alarm = new AlarmService(client, this.realtime);
+		this.application = new ApplicationService(client, this.realtime);
+		this.audit = new AuditService(client);
+		this.core = client;
+		this.deviceRegistration = new DeviceRegistrationService(client);
+		this.deviceRegistrationBulk = new DeviceRegistrationBulkService(client);
+		this.event = new EventService(client, this.realtime);
+		this.inventory = new InventoryService(client, this.realtime);
+		this.inventoryBinary = new InventoryBinaryService(client);
+		this.inventoryRole = new InventoryRoleService(client);
+		this.measurement = new MeasurementService(client, this.realtime);
+		this.operation = new OperationService(client);
+		this.operationBulk = new OperationBulkService(client);
+		this.options = {
+			security: new TenantSecurityOptionsService(client),
+			system: new SystemOptionsService(client),
+			login: new TenantLoginOptionsService(client),
+			tenant: new TenantOptionsService(client)
+		};
+		this.role = new InventoryRoleService(client);
+		this.tenant = new TenantService(client);
+		this.user = new UserService(client);
+		this.userGroup = new UserGroupService(client);
+		this.userRole = new UserRoleService(client);
+		this.identity = new IdentityService(client);
+		this.smartGroups = new SmartGroupsService(client);
+		this.smartRules = new SmartRulesService(client);
+	}
+	/**
+	* Allows to change the current Authentication
+	* @param auth The new Authentication information.
+	*/
+	setAuth(auth) {
+		this.core.setAuth(auth);
+		this.realtime.disconnect();
+	}
+};
+
+//#endregion
+export { Client };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/alarm/AlarmService.mjs

@@ -0,0 +1,198 @@
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { Service } from "../core/Service.mjs";
+import "../core/index.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/alarm/AlarmService.js
+/**
+* This class allows for managing alarms.
+*/
+var AlarmService = class extends Service {
+	constructor() {
+		super(...arguments);
+		this.baseUrl = "alarm";
+		this.listUrl = "alarms";
+		this.propertyName = "alarms";
+		this.channel = "/alarms/*";
+	}
+	/**
+	* Gets the details of selected alarms.
+	*
+	* @param {string|number|IIdentified} entityOrId Entity or Id of the entity.
+	*
+	* @returns Response wrapped in [[IResult]]
+	*
+	* **Example**
+	* ```typescript
+	*
+	*    const alarmId: number = 1;
+	*
+	*    (async () => {
+	*      const {data, res} = await alarmService.detail(alarmId);
+	*    })();
+	* ```
+	*/
+	detail(entityOrId) {
+		const _super = Object.create(null, { detail: { get: () => super.detail } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.detail.call(this, entityOrId);
+		});
+	}
+	/**
+	* Creates a new alarm.
+	*
+	* @param {IAlarm} entity Alarm object with mandantory fragments.
+	*
+	* @returns Response wrapped in [[IResult]]
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const mandantoryObject: IAlarm = {
+	*    severity: Severity.CRITICAL,
+	*    source: device,
+	*    text: 'I am an Alarm!',
+	*    time: '2018-05-02T10:08:00Z',
+	*    type: 'device-type-here',
+	*  };
+	*
+	*  (async () => {
+	*    const {data, res} = await alarmService.create(mandantoryObject);
+	*  })();
+	* ```
+	*/
+	create(entity) {
+		const _super = Object.create(null, { create: { get: () => super.create } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.create.call(this, entity);
+		});
+	}
+	/**
+	* Updates alarm data.
+	*
+	* @param {Partial<IAlarm>} entity Partial alarm to update, must have `id`.
+	*
+	* @returns Response wrapped in [[IResult]]
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const partialUpdateObject: Partial<IAlarm> = {
+	*    id: 123,
+	*    severity: Severity.MINOR,
+	*    source: device,
+	*    text: 'Changed Alarm!'
+	*  };
+	*
+	*  (async () => {
+	*    const {data, res} = await alarmService.update(partialUpdateObject);
+	*  })();
+	* ```
+	*/
+	update(entity) {
+		const _super = Object.create(null, { update: { get: () => super.update } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.update.call(this, entity);
+		});
+	}
+	/**
+	* Updates alarm data in bulk and with additional query filters.
+	*
+	* @param {Partial<IAlarm>} entity Partial alarm object.
+	* @param {Record<string, string | number | boolean>} filters Additional query filters.
+	*
+	* @returns Response in form of { IFetchResponse }
+	*
+	* **Example**
+	* ```typescript
+	*
+	* const partialUpdateObject: Partial<IAlarm> = {
+	*   status: AlarmStatus.CLEARED
+	* };
+	*
+	* const additionalFilters: Record<string, string | number | boolean> = {
+	*   resolved: false,
+	*   severity: Severity.MINOR
+	* };
+	*
+	* (async () => {
+	*   const response = await alarmService.updateBulk(partialUpdateObject, additionalFilters);
+	* })();
+	* ```
+	* In this example, every unresolved alarm that has a severity of `Severity.MINOR` will be updated with a status of `AlarmStatus.CLEARED`.
+	*/
+	updateBulk(entity, filters) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const params = new URLSearchParams(Object.entries(filters).map(([key, val]) => [key, String(val)]));
+			const url = this.getDetailUrl(entity).replace(/\/$/, "") + `?${params.toString()}`;
+			const method = "PUT";
+			const body = JSON.stringify(this.onBeforeUpdate(entity));
+			return yield this.fetch(url, this.changeFetchOptions({
+				method,
+				body,
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json"
+				}
+			}, url));
+		});
+	}
+	/**
+	* Gets the list of alarms filtered by parameters.
+	*
+	* @returns Response wrapped in [[IResultList]]
+	*
+	* @param {AlarmQueryFilter} filter Filters to query alarms.
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const filter: AlarmQueryFilter = {
+	*     severity: Severity.MAJOR,
+	*     pageSize: 100,
+	*     withTotalPages: true
+	*   };
+	*
+	*   (async () => {
+	*     const {data, res, paging} = await alarmService.list(filter);
+	*   })();
+	* ```
+	*/
+	list() {
+		const _super = Object.create(null, { list: { get: () => super.list } });
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			return _super.list.call(this, filter);
+		});
+	}
+	/**
+	* Gets the number of alarms based on the filter criteria.
+	*
+	* @returns Response wrapped in [[IResultList]]
+	*
+	* @param {AlarmQueryFilter} filter Filters to query alarms.
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const filter: AlarmQueryFilter = {
+	*     severity: Severity.MAJOR,
+	*   };
+	*
+	*   (async () => {
+	*     const {data, res} = await alarmService.count(filter);
+	*   })();
+	* ```
+	*/
+	count() {
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			const url = `${this.listUrl}/count`;
+			const res = yield this.fetch(url, this.changeFetchOptions({ params: filter }, url));
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+};
+
+//#endregion
+export { AlarmService };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/alarm/AlarmStatus.mjs

@@ -0,0 +1,16 @@
+import { gettext } from "../gettext-typed.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/alarm/AlarmStatus.js
+const AlarmStatus = {
+	ACKNOWLEDGED: "ACKNOWLEDGED",
+	CLEARED: "CLEARED",
+	ACTIVE: "ACTIVE"
+};
+const ALARM_STATUS_LABELS = {
+	ACKNOWLEDGED: gettext("Acknowledged`alarm`"),
+	CLEARED: gettext("Cleared`alarm`"),
+	ACTIVE: gettext("Active`alarm`")
+};
+
+//#endregion
+export { ALARM_STATUS_LABELS, AlarmStatus };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/alarm/index.mjs

@@ -0,0 +1,4 @@
+import { AlarmService } from "./AlarmService.mjs";
+import { ALARM_STATUS_LABELS, AlarmStatus } from "./AlarmStatus.mjs";
+
+export {  };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/application/ApplicationAvailability.mjs

@@ -0,0 +1,12 @@
+import { gettext } from "../gettext.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/application/ApplicationAvailability.js
+var ApplicationAvailability;
+(function(ApplicationAvailability) {
+	ApplicationAvailability[ApplicationAvailability["MARKET"] = gettext("MARKET")] = "MARKET";
+	ApplicationAvailability[ApplicationAvailability["PRIVATE"] = gettext("PRIVATE")] = "PRIVATE";
+	ApplicationAvailability[ApplicationAvailability["SHARED"] = gettext("SHARED")] = "SHARED";
+})(ApplicationAvailability || (ApplicationAvailability = {}));
+
+//#endregion
+export { ApplicationAvailability };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/application/ApplicationBinaryService.mjs

@@ -0,0 +1,166 @@
+import { __toESM } from "../../../../../../../../../../_virtual/rolldown_runtime.mjs";
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { Service } from "../core/Service.mjs";
+import "../core/index.mjs";
+import { require_form_data } from "../../../../../../../../form-data@4.0.4/node_modules/form-data/lib/form_data.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/application/ApplicationBinaryService.js
+var import_form_data = /* @__PURE__ */ __toESM(require_form_data());
+var ApplicationBinaryService = class extends Service {
+	constructor(client, applicationOrId) {
+		super(client);
+		this.listUrl = "binaries";
+		this.propertyName = "attachments";
+		this.baseUrl = `application/applications/${this.getIdString(applicationOrId)}`;
+	}
+	upload(binary, fileName, uploadParamsOverride) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const url = (uploadParamsOverride === null || uploadParamsOverride === void 0 ? void 0 : uploadParamsOverride.listUrl) || this.listUrl;
+			const method = "POST";
+			const body = this.createBinaryRequestBody(binary, fileName, uploadParamsOverride);
+			let bodyHeaders;
+			if (typeof body.getHeaders === "function") bodyHeaders = body.getHeaders();
+			const headers = Object.assign((uploadParamsOverride === null || uploadParamsOverride === void 0 ? void 0 : uploadParamsOverride.headers) || { Accept: "application/json" }, bodyHeaders);
+			const res = yield this.fetch(url, {
+				method,
+				body,
+				headers
+			});
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	uploadApplicationVersion(archive, version, tags = []) {
+		return this.upload(archive, archive.name, {
+			listUrl: "versions",
+			headers: { Accept: "application/vnd.com.nsn.cumulocity.applicationVersion+json;charset=UTF-8;ver=0.9" },
+			bodyFileProperty: "applicationBinary",
+			requestBody: { applicationVersion: Object.assign({ version }, (tags === null || tags === void 0 ? void 0 : tags.length) && { tags }) }
+		});
+	}
+	uploadWithProgressXhr(binary, onProgress, fileName, uploadParamsOverride) {
+		const url = `/${this.baseUrl}/${(uploadParamsOverride === null || uploadParamsOverride === void 0 ? void 0 : uploadParamsOverride.listUrl) || this.listUrl}`;
+		const method = "POST";
+		const body = this.createBinaryRequestBody(binary, fileName, uploadParamsOverride);
+		let bodyHeaders;
+		if (typeof body.getHeaders === "function") bodyHeaders = body.getHeaders();
+		const headers = this.client.getFetchOptions().headers;
+		Object.assign(headers, (uploadParamsOverride === null || uploadParamsOverride === void 0 ? void 0 : uploadParamsOverride.headers) || { Accept: "application/json" });
+		Object.assign(headers, bodyHeaders);
+		const xhr = new XMLHttpRequest();
+		xhr.open(method, url, true);
+		for (const key in headers) if (headers.hasOwnProperty(key)) xhr.setRequestHeader(key, headers[key]);
+		xhr.upload.addEventListener("progress", onProgress);
+		let xhrBody;
+		if (typeof body.getBuffer === "function") xhrBody = body.getBuffer();
+		else xhrBody = body;
+		xhr.send(xhrBody);
+		return xhr;
+	}
+	getXMLHttpResponse(xhr) {
+		return new Promise((res, rej) => {
+			xhr.addEventListener("loadend", () => {
+				xhr.readyState === 4 && (xhr.status === 200 || xhr.status === 201) ? res(JSON.parse(xhr.responseText)) : rej(xhr.responseText ? { data: JSON.parse(xhr.responseText) } : "Could not upload file.");
+			});
+		});
+	}
+	list(filter) {
+		const _super = Object.create(null, { list: { get: () => super.list } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.list.call(this, filter);
+		});
+	}
+	delete(binaryOrId) {
+		const _super = Object.create(null, { delete: { get: () => super.delete } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.delete.call(this, binaryOrId);
+		});
+	}
+	listPlugins() {
+		return __awaiter(this, void 0, void 0, function* () {
+			const headers = { accept: "application/json" };
+			const url = `${this.listUrl}/plugins`;
+			const res = yield this.fetch(url, { headers });
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	addPlugin(pluginName, pluginFile) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const url = `${this.listUrl}/plugins/${encodeURIComponent(pluginName)}`;
+			const method = "POST";
+			const body = new import_form_data.default();
+			const bufferOrStream = pluginFile instanceof ArrayBuffer ? Buffer.from(pluginFile) : pluginFile;
+			body.append("file", bufferOrStream);
+			const res = yield this.fetch(url, {
+				method,
+				body,
+				headers: { accept: "application/json" }
+			});
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	removePlugin(pluginName) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const method = "DELETE";
+			const headers = { accept: "application/json" };
+			const url = `${this.listUrl}/plugins/${pluginName}`;
+			const res = yield this.fetch(url, {
+				method,
+				headers
+			});
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	updateFiles(files) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const url = `${this.listUrl}/files`;
+			const method = "POST";
+			const body = new import_form_data.default();
+			files.forEach((file) => {
+				const bufferOrStream = file.contents instanceof ArrayBuffer ? Buffer.from(file.contents) : file.contents;
+				body.append(file.path, bufferOrStream);
+			});
+			const res = yield this.fetch(url, {
+				method,
+				body,
+				headers: { accept: "application/json" }
+			});
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	downloadArchive(binaryId) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const url = `${this.listUrl}/${binaryId}`;
+			return yield this.fetch(url);
+		});
+	}
+	createBinaryRequestBody(binary, fileName, uploadParamsOverride) {
+		const body = new import_form_data.default();
+		const bufferOrStream = binary instanceof ArrayBuffer ? Buffer.from(binary) : binary;
+		let uploadFileName = fileName;
+		if (typeof File !== "undefined" && binary instanceof File) uploadFileName = binary.name;
+		body.append((uploadParamsOverride === null || uploadParamsOverride === void 0 ? void 0 : uploadParamsOverride.bodyFileProperty) || "file", bufferOrStream, uploadFileName);
+		body.append("fileName", uploadFileName);
+		if (uploadParamsOverride === null || uploadParamsOverride === void 0 ? void 0 : uploadParamsOverride.requestBody) {
+			for (const key in uploadParamsOverride.requestBody) if (uploadParamsOverride.requestBody.hasOwnProperty(key)) body.append(key, JSON.stringify(uploadParamsOverride.requestBody[key]));
+		}
+		return body;
+	}
+};
+
+//#endregion
+export { ApplicationBinaryService };