@geowiki/evoland-api-proxy 0.15.0-dev.1

package/dist/index.mjs

@@ -0,0 +1,1538 @@
+// core/ApiError.ts
+var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  #isResolved;
+  #isRejected;
+  #isCancelled;
+  #cancelHandlers;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(executor) {
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise((resolve2, reject) => {
+      this.#resolve = resolve2;
+      this.#reject = reject;
+      const onResolve = (value) => {
+        var _a;
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isResolved = true;
+        (_a = this.#resolve) == null ? void 0 : _a.call(this, value);
+      };
+      const onReject = (reason) => {
+        var _a;
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isRejected = true;
+        (_a = this.#reject) == null ? void 0 : _a.call(this, reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this.#isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this.#isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this.#isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.#promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.#promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.#promise.finally(onFinally);
+  }
+  cancel() {
+    var _a;
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+      return;
+    }
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.#cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.#cancelHandlers.length = 0;
+    (_a = this.#reject) == null ? void 0 : _a.call(this, new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+};
+
+// core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "",
+  VERSION: "0.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// models/TaskStatus.ts
+var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2["ASSIGNED"] = "ASSIGNED";
+  TaskStatus2["SKIPPED"] = "SKIPPED";
+  TaskStatus2["USER_DISCARDED"] = "USER_DISCARDED";
+  TaskStatus2["DISCARDED"] = "DISCARDED";
+  TaskStatus2["IN_REVIEW"] = "IN_REVIEW";
+  TaskStatus2["SUBMITTED"] = "SUBMITTED";
+  TaskStatus2["TO_FIX"] = "TO_FIX";
+  TaskStatus2["ACCEPTED"] = "ACCEPTED";
+  return TaskStatus2;
+})(TaskStatus || {});
+
+// models/TaskType.ts
+var TaskType = /* @__PURE__ */ ((TaskType2) => {
+  TaskType2["ANNOTATION"] = "ANNOTATION";
+  TaskType2["QUESTIONNAIRE"] = "QUESTIONNAIRE";
+  return TaskType2;
+})(TaskType || {});
+
+// models/UserRank.ts
+var UserRank = /* @__PURE__ */ ((UserRank2) => {
+  UserRank2["MEMBER"] = "MEMBER";
+  UserRank2["ADMIN"] = "ADMIN";
+  UserRank2["OWNER"] = "OWNER";
+  return UserRank2;
+})(UserRank || {});
+
+// core/request.ts
+import axios from "axios";
+import FormData from "form-data";
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var isSuccess = (status) => {
+  return status >= 200 && status < 300;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    var _a;
+    if ((_a = options.path) == null ? void 0 : _a.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options, formData) => {
+  const token = await resolve(options, config.TOKEN);
+  const username = await resolve(options, config.USERNAME);
+  const password = await resolve(options, config.PASSWORD);
+  const additionalHeaders = await resolve(options, config.HEADERS);
+  const formHeaders = typeof (formData == null ? void 0 : formData.getHeaders) === "function" && (formData == null ? void 0 : formData.getHeaders()) || {};
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers,
+    ...formHeaders
+  }).filter(([_, value]) => isDefined(value)).reduce(
+    (headers2, [key, value]) => ({
+      ...headers2,
+      [key]: String(value)
+    }),
+    {}
+  );
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return headers;
+};
+var getRequestBody = (options) => {
+  if (options.body) {
+    return options.body;
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel, axiosClient) => {
+  const source = axios.CancelToken.source();
+  const requestConfig = {
+    url,
+    headers,
+    data: body ?? formData,
+    method: options.method,
+    withCredentials: config.WITH_CREDENTIALS,
+    cancelToken: source.token
+  };
+  onCancel(() => source.cancel("The user aborted a request."));
+  try {
+    return await axiosClient.request(requestConfig);
+  } catch (error) {
+    const axiosError = error;
+    if (axiosError.response) {
+      return axiosError.response;
+    }
+    throw error;
+  }
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers[responseHeader];
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = (response) => {
+  if (response.status !== 204) {
+    return response.data;
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options, axiosClient = axios) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options, formData);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(
+          config,
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel,
+          axiosClient
+        );
+        const responseBody = getResponseBody(response);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
+        const result = {
+          url,
+          ok: isSuccess(response.status),
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// services/AiService.ts
+var AiService = class {
+  /**
+   * Performs an automatic annotation of a location based on provided inputs by user.
+   * @param requestBody
+   * @returns ActiveLearningResponse Successful Response
+   * @throws ApiError
+   */
+  static performActiveLearningActivelearningPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/activelearning/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+};
+
+// services/LocationService.ts
+var LocationService = class {
+  /**
+   * From a (lon, lat) coordinate and width and height expressed in meters, obtains a UTM tile of the given width and height for the best possible UTM projection. The user gets back the
+   * @param lon
+   * @param lat
+   * @param width
+   * @param height
+   * @returns PolygonResponse Successful Response
+   * @throws ApiError
+   */
+  static getPolygonUtmlocationLonLonLatLatWidthWidthHeightHeightGet(lon, lat, width, height) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/utmlocation/lon={lon}&lat={lat}&width={width}&height={height}",
+      path: {
+        "lon": lon,
+        "lat": lat,
+        "width": width,
+        "height": height
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * From a location id, a project id and a reference date, gets a task response containing information about the location: the polygon with epsg and UTM bounds aligned in the grid. It also gets the task information for the user on that task if a task exists and is assigned to the current user.
+   * @param requestBody
+   * @returns TaskResponse Successful Response
+   * @throws ApiError
+   */
+  static getLocationGetlocationPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/getlocation/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the composite assets of a specific type from a location. Cannot get submitted annotations.
+   * @param requestBody
+   * @returns LocationAssetsResponse Successful Response
+   * @throws ApiError
+   */
+  static getLocationAssetsLocationtypeassetsPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/locationtypeassets/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get all the assets for a given location.
+   * @param requestBody
+   * @returns LocationAssetsResponse Successful Response
+   * @throws ApiError
+   */
+  static getAllAssetsLocationassetsPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/locationassets/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get a summary of the time series informations for a specific location.
+   * @param projectId
+   * @param locationId
+   * @returns TimeseriesInfoResponse Successful Response
+   * @throws ApiError
+   */
+  static timeseriesInfoTimeseriesassetsProjectIdProjectIdLocationIdLocationIdGet(projectId, locationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/timeseriesassets/project_id={project_id}&location_id={location_id}",
+      path: {
+        "project_id": projectId,
+        "location_id": locationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Creates a location from a given lon/lat/width/height and project id. Only the admin and owner users can add a location to a project.
+   * @param requestBody
+   * @returns LocationCreatedResponse Successful Response
+   * @throws ApiError
+   */
+  static createLocationCreatelocationPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/createlocation/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Process annotation bytes into tiff
+   * @param requestBody
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static processAnnotationProcessannotationPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/processannotation",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Process byte data into tiff
+   * @param requestBody
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static processRasterProcessrasterPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/processraster",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Accepts a geojson, validates rows, insert in location_task_mapping and returns a json for each row's status
+   * @param formData
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static uploadLocationTaskUploadlocationtaskPost(formData) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/uploadlocationtask/",
+      formData,
+      mediaType: "multipart/form-data",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Bulk Upload Locations
+   * Accepts a geojson, validates rows and insert in locations table, returns status of inserted and error row
+   * @param formData
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static bulkUploadLocationsUploadlocationsPost(formData) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/uploadlocations/",
+      formData,
+      mediaType: "multipart/form-data",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Bulk Upload Review Tasks
+   * Upload tasks which has been selected for review
+   * @param formData
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static bulkUploadReviewTasksUploadreviewtasksPost(formData) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/uploadreviewtasks",
+      formData,
+      mediaType: "multipart/form-data",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+};
+
+// services/ProjectService.ts
+var ProjectService = class {
+  /**
+   * Read Root
+   * @returns AboutResponse Successful Response
+   * @throws ApiError
+   */
+  static readRootGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/"
+    });
+  }
+  /**
+   * Get personal information by decoding the user token (specified inside the Authorization header field).
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static getUserMeGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/me/"
+    });
+  }
+  /**
+   * Returns the available layers from the WMS service.
+   * @returns LayersResponse Successful Response
+   * @throws ApiError
+   */
+  static getAvailableLayersAvailablelayersGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/availablelayers/"
+    });
+  }
+  /**
+   * Return the WC labels codes for a project, with their names and colors.
+   * @param projectId
+   * @returns LabelsResponse Successful Response
+   * @throws ApiError
+   */
+  static getLabelsLabelsProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/labels/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Return the combinatory (primary/secondary/tertiary) label codes, with their names and colors.
+   * @param projectId
+   * @returns LabelsResponse Successful Response
+   * @throws ApiError
+   */
+  static getCombinationLabelsCombinationlabelsProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/combinationlabels/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the project information from a specific project.
+   * @param projectId
+   * @returns ProjectDetailElement Successful Response
+   * @throws ApiError
+   */
+  static projectDetailProjectdetailProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/projectdetail/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the project information, user statistics from a specific project.
+   * @param projectId
+   * @returns UserProjectElement Successful Response
+   * @throws ApiError
+   */
+  static projectInfoProjectinfoProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/projectinfo/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Lists all the project that the user is part of. If the user is an administrator, then lists all the projects currently in the datbase, including the deleted projects.
+   * @param startidx
+   * @param amount
+   * @returns ListProjectResponse Successful Response
+   * @throws ApiError
+   */
+  static listProjectsListprojectsStartidxStartidxAmountAmountGet(startidx, amount) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/listprojects/startidx={startidx}&amount={amount}",
+      path: {
+        "startidx": startidx,
+        "amount": amount
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Creates a project, adding the curent user as owner. Only GeoWiki admins can create a new project.
+   * @param requestBody
+   * @returns CreateProjectResponse Successful Response
+   * @throws ApiError
+   */
+  static createProjectCreateprojectPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/createproject/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the project result set information for all the location and tasks linked to a project
+   * @param projectId
+   * @param isGeoJson
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static projectResultSetProjectresultsetProjectIdProjectIdIsGeoJsonIsGeoJsonGet(projectId, isGeoJson) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/projectresultset/project_id={project_id}&is_geo_json={is_geo_json}",
+      path: {
+        "project_id": projectId,
+        "is_geo_json": isGeoJson
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Create a new user in the database. Only admins can create a new user.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static createUserCreateuserPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/createuser/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Sets the user role in a project. If the user does not exists, then adds it to the project with the target role.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static setUserRoleSetuserrolePost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/setuserrole/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Sets the user role in a project. If the user does not exists, then adds it to the project with the target role.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static setUserDetailSetuserdetailPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/setuserdetail/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get user role and project
+   * @param userId
+   * @returns GetUserRoleProjectResponse Successful Response
+   * @throws ApiError
+   */
+  static getUserRoleProjectGetuserroleprojectUserIdUserIdGet(userId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/getuserroleproject/user_id={user_id}",
+      path: {
+        "user_id": userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Removes an user from a project.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static removeUserRemoveuserPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/removeuser/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Returns a set of locations, or a sets of clusters given a bounding box
+   * @param requestBody
+   * @returns ListLocationsResponse Successful Response
+   * @throws ApiError
+   */
+  static searchLocationsLocationsPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/locations/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Returns a summary of locations,groups
+   * @param projectId
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static getLocationsSummaryLocationssummaryProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/locationssummary/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the table of tasks of the user if an user is specified.
+   * @param locationProjectId
+   * @param taskForReview
+   * @param id
+   * @param orderBy
+   * @param search
+   * @param status
+   * @param statusIn
+   * @param dateLte
+   * @param dateGte
+   * @param pageIdx
+   * @param pageSize
+   * @param userId
+   * @param userUserAlias
+   * @param userOrderBy
+   * @param locationLocationId
+   * @param locationOrderBy
+   * @param groupName
+   * @param groupOrderBy
+   * @returns TaskFilterResponse Successful Response
+   * @throws ApiError
+   */
+  static getTasksTasksGet(locationProjectId, taskForReview, id, orderBy, search, status, statusIn, dateLte, dateGte, pageIdx, pageSize, userId, userUserAlias, userOrderBy, locationLocationId, locationOrderBy, groupName, groupOrderBy) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/tasks",
+      query: {
+        "task_for_review": taskForReview,
+        "id": id,
+        "order_by": orderBy,
+        "search": search,
+        "status": status,
+        "status__in": statusIn,
+        "date__lte": dateLte,
+        "date__gte": dateGte,
+        "page_idx": pageIdx,
+        "page_size": pageSize,
+        "user__id": userId,
+        "user__user_alias": userUserAlias,
+        "user__order_by": userOrderBy,
+        "location__location_id": locationLocationId,
+        "location__order_by": locationOrderBy,
+        "location__project_id": locationProjectId,
+        "group__name": groupName,
+        "group__order_by": groupOrderBy
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get a random task for the user, based on the same filter available in the GET /tasks call.
+   * @param locationProjectId
+   * @param taskForReview
+   * @param id
+   * @param orderBy
+   * @param search
+   * @param status
+   * @param statusIn
+   * @param dateLte
+   * @param dateGte
+   * @param pageIdx
+   * @param pageSize
+   * @param userId
+   * @param userUserAlias
+   * @param userOrderBy
+   * @param locationLocationId
+   * @param locationOrderBy
+   * @param groupName
+   * @param groupOrderBy
+   * @returns TaskResponse Successful Response
+   * @throws ApiError
+   */
+  static getRandomTaskRandomtaskGet(locationProjectId, taskForReview, id, orderBy, search, status, statusIn, dateLte, dateGte, pageIdx, pageSize, userId, userUserAlias, userOrderBy, locationLocationId, locationOrderBy, groupName, groupOrderBy) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/randomtask",
+      query: {
+        "task_for_review": taskForReview,
+        "id": id,
+        "order_by": orderBy,
+        "search": search,
+        "status": status,
+        "status__in": statusIn,
+        "date__lte": dateLte,
+        "date__gte": dateGte,
+        "page_idx": pageIdx,
+        "page_size": pageSize,
+        "user__id": userId,
+        "user__user_alias": userUserAlias,
+        "user__order_by": userOrderBy,
+        "location__location_id": locationLocationId,
+        "location__order_by": locationOrderBy,
+        "location__project_id": locationProjectId,
+        "group__name": groupName,
+        "group__order_by": groupOrderBy
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Returns a list of groups available within a project.
+   * @param projectId
+   * @returns ProjectGroupResponse Successful Response
+   * @throws ApiError
+   */
+  static getProjectGroupsProjectgroupsProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/projectgroups/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Selects an active group for a project.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static selectProjectGroupProjectselectgroupPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/projectselectgroup/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * List all the users within a project.
+   * @param projectId
+   * @returns UserOut Successful Response
+   * @throws ApiError
+   */
+  static projectAllUsersProjectusersProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/projectusers/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Returns the task information for a specific location. The task returned is the task with the latest update.
+   * @param locationId
+   * @param projectId
+   * @param referenceDate
+   * @returns LocationTaskAnnotationResponse Successful Response
+   * @throws ApiError
+   */
+  static locationLatestTaskLocationtaskLocationIdLocationIdProjectIdProjectIdReferenceDateReferenceDateGet(locationId, projectId, referenceDate) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/locationtask/location_id={location_id}&project_id={project_id}&reference_date={reference_date}",
+      path: {
+        "location_id": locationId,
+        "project_id": projectId,
+        "reference_date": referenceDate
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+};
+
+// services/QuestionService.ts
+var QuestionService = class {
+  /**
+   * Get Project Questions Answers
+   * get pairs of questions and answers associated with a project
+   * @param projectId
+   * @returns Questionnaire Successful Response
+   * @throws ApiError
+   */
+  static getProjectQuestionsAnswersQuestionsAnswersProjectIdProjectIdGet(projectId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/questions_answers/project_id={project_id}",
+      path: {
+        "project_id": projectId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+};
+
+// services/StatisticService.ts
+var StatisticService = class {
+  /**
+   * Get User Statistics
+   * For each user within a project, get statistics related to the tasks that were updated.
+   * @param projectId
+   * @param endDate
+   * @param startDate
+   * @param isContractualData
+   * @param filterUserId
+   * @returns UserStatisticsResponse Successful Response
+   * @throws ApiError
+   */
+  static getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateFilterUserIdFilterUserIdIsContractualDataIsContractualDataGet(projectId, endDate, startDate, isContractualData, filterUserId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/userstatistics/project_id={project_id}&start_date={start_date}&end_date={end_date}&filter_user_id={filter_user_id}&is_contractual_data={is_contractual_data}",
+      path: {
+        "project_id": projectId,
+        "end_date": endDate,
+        "start_date": startDate,
+        "is_contractual_data": isContractualData,
+        "filter_user_id": filterUserId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get User Statistics
+   * For each user within a project, get statistics related to the tasks that were updated.
+   * @param projectId
+   * @param endDate
+   * @param startDate
+   * @param filterUserId
+   * @param isContractualData
+   * @returns UserStatisticsResponse Successful Response
+   * @throws ApiError
+   */
+  static getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateFilterUserIdFilterUserIdGet(projectId, endDate, startDate, filterUserId, isContractualData = false) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/userstatistics/project_id={project_id}&start_date={start_date}&end_date={end_date}&filter_user_id={filter_user_id}",
+      path: {
+        "project_id": projectId,
+        "end_date": endDate,
+        "start_date": startDate,
+        "filter_user_id": filterUserId
+      },
+      query: {
+        "is_contractual_data": isContractualData
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get User Statistics
+   * For each user within a project, get statistics related to the tasks that were updated.
+   * @param projectId
+   * @param endDate
+   * @param startDate
+   * @param isContractualData
+   * @param filterUserId
+   * @returns UserStatisticsResponse Successful Response
+   * @throws ApiError
+   */
+  static getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateGet(projectId, endDate, startDate, isContractualData = false, filterUserId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/userstatistics/project_id={project_id}&start_date={start_date}&end_date={end_date}",
+      path: {
+        "project_id": projectId,
+        "end_date": endDate,
+        "start_date": startDate
+      },
+      query: {
+        "is_contractual_data": isContractualData,
+        "filter_user_id": filterUserId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+};
+
+// services/TaskService.ts
+var TaskService = class {
+  /**
+   * Get all the possible task statuses
+   * @returns string Successful Response
+   * @throws ApiError
+   */
+  static getTaskStatusesTaskstatusesGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/taskstatuses/"
+    });
+  }
+  /**
+   * Get the task information for a specific task id.
+   * @param taskId
+   * @returns TaskResponse Successful Response
+   * @throws ApiError
+   */
+  static getTaskGettaskTaskIdTaskIdGet(taskId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/gettask/task_id={task_id}",
+      path: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Create a task for an user for a specific location, if no task exists for that user on that location. Then returns the created/existing task and location info.
+   * @param requestBody
+   * @returns TaskResponse Successful Response
+   * @throws ApiError
+   */
+  static createTaskCreatetaskPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/createtask/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Returns a new task for an user on a new location. If the user already has a task in the ASSIGNED state, it will be returned.
+   * @param requestBody
+   * @returns TaskResponse Successful Response
+   * @throws ApiError
+   */
+  static getNextLocationNexttaskPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/nexttask/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Deletes a specific task from the database and the related events. Submitted annotations are kept in the database for the location. Only admin users can delete tasks.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static deleteTaskDeletetaskPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/deletetask/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the latest task annotation for a specific task id.
+   * @param taskId
+   * @returns TaskAnnotationResponse Successful Response
+   * @throws ApiError
+   */
+  static getTaskAnnotationAssetTaskannotationTaskIdTaskIdGet(taskId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/taskannotation/task_id={task_id}",
+      path: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get all the annotations for a specific task id.
+   * @param taskId
+   * @returns LocationAssetsResponse Successful Response
+   * @throws ApiError
+   */
+  static getTaskAnnotationAssetsTaskannotationsTaskIdTaskIdGet(taskId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/taskannotations/task_id={task_id}",
+      path: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Saves an annotation for a task.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static saveAnnotationSaveannotationPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/saveannotation/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the saved annotation for a specific task (if it exists).
+   * @param taskId
+   * @returns GetSavedAnnotationResponse Successful Response
+   * @throws ApiError
+   */
+  static getSavedAnnotationGetsavedannotationTaskIdTaskIdGet(taskId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/getsavedannotation/task_id={task_id}",
+      path: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Save Questionnaire
+   * Save questionnaire for a task
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static saveQuestionnaireSavequestionnairePost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/savequestionnaire",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get change detection details associated with a task
+   * @param taskId
+   * @returns TaskChangeElement Successful Response
+   * @throws ApiError
+   */
+  static getTaskChangeDetailTaskchangedetailsPost(taskId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/taskchangedetails/",
+      query: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get change detection details associated with a task
+   * @param taskId
+   * @returns TaskGeometryElement Successful Response
+   * @throws ApiError
+   */
+  static getTaskGeometryDetailTaskgeometryetailsPost(taskId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/taskgeometryetails/",
+      query: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Updates the status of a task. Depending on the previous status, the role of the user and the target status, required required parameters may vary
+   * @param requestBody
+   * @returns UpdateTaskResponse Successful Response
+   * @throws ApiError
+   */
+  static updateTaskUpdatetaskPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/updatetask/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Adds a comment from an user on a task.
+   * @param requestBody
+   * @returns GenericResponse Successful Response
+   * @throws ApiError
+   */
+  static taskCommentTaskcommentPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/taskcomment/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the events of a task.
+   * @param taskId
+   * @returns TaskEventOut Successful Response
+   * @throws ApiError
+   */
+  static getTaskEventsTaskeventsTaskIdTaskIdGet(taskId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/taskevents/task_id={task_id}",
+      path: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the latest comments for every task in the provided list. The response will be a list of comments ordered in the same way as the input list. An empty string is returned if no latest comment was found.
+   * @param requestBody
+   * @returns TaskLatestCommentResponse Successful Response
+   * @throws ApiError
+   */
+  static taskLatestComomentsTasklatestcommentPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/tasklatestcomment/",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * Get the reference dates for current task on a location from meta_data.The response model will be a list of string
+   * @param locationId
+   * @param projectId
+   * @param assetType
+   * @returns any Successful Response
+   * @throws ApiError
+   */
+  static taskReferenceDatesGettaskreferencedatesProjectIdProjectIdLocationIdLocationIdAssetTypeAssetTypeGet(locationId, projectId, assetType) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/gettaskreferencedates/project_id={project_id}&location_id={location_id}&asset_type={asset_type}",
+      path: {
+        "location_id": locationId,
+        "project_id": projectId,
+        "asset_type": assetType
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  /**
+   * returns a list of user provided answers associated with a task
+   * @param taskId
+   * @returns any[] Successful Response
+   * @throws ApiError
+   */
+  static getTaskAnswersTaskanswersTaskIdTaskIdGet(taskId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/taskanswers/task_id={task_id}",
+      path: {
+        "task_id": taskId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+};
+export {
+  AiService,
+  ApiError,
+  CancelError,
+  CancelablePromise,
+  LocationService,
+  OpenAPI,
+  ProjectService,
+  QuestionService,
+  StatisticService,
+  TaskService,
+  TaskStatus,
+  TaskType,
+  UserRank
+};