@eeplatform/core 1.4.3 → 1.4.5

package/dist/index.js

@@ -10384,7 +10384,7 @@ var require_ms = __commonJS({
       options = options || {};
       var type = typeof val;
       if (type === "string" && val.length > 0) {
-        return parse(val);
+        return parse3(val);
       } else if (type === "number" && isNaN(val) === false) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
@@ -10392,7 +10392,7 @@ var require_ms = __commonJS({
         "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
       );
     };
-    function parse(str) {
+    function parse3(str) {
       str = String(str);
       if (str.length > 100) {
         return;
@@ -10839,7 +10839,7 @@ var require_follow_redirects = __commonJS({
     (function detectUnsupportedEnvironment() {
       var looksLikeNode = typeof process !== "undefined";
       var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-      var looksLikeV8 = isFunction2(Error.captureStackTrace);
+      var looksLikeV8 = isFunction3(Error.captureStackTrace);
       if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
         console.warn("The follow-redirects package should be excluded from browser builds.");
       }
@@ -10934,7 +10934,7 @@ var require_follow_redirects = __commonJS({
       if (!isString2(data) && !isBuffer2(data)) {
         throw new TypeError("data should be a string, Buffer or Uint8Array");
       }
-      if (isFunction2(encoding)) {
+      if (isFunction3(encoding)) {
         callback = encoding;
         encoding = null;
       }
@@ -10954,10 +10954,10 @@ var require_follow_redirects = __commonJS({
       }
     };
     RedirectableRequest.prototype.end = function(data, encoding, callback) {
-      if (isFunction2(data)) {
+      if (isFunction3(data)) {
         callback = data;
         data = encoding = null;
-      } else if (isFunction2(encoding)) {
+      } else if (isFunction3(encoding)) {
         callback = encoding;
         encoding = null;
       }
@@ -11158,7 +11158,7 @@ var require_follow_redirects = __commonJS({
       if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
         removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
       }
-      if (isFunction2(beforeRedirect)) {
+      if (isFunction3(beforeRedirect)) {
         var responseDetails = {
           headers: response.headers,
           statusCode
@@ -11193,7 +11193,7 @@ var require_follow_redirects = __commonJS({
             options = validateUrl(input);
             input = { protocol };
           }
-          if (isFunction2(options)) {
+          if (isFunction3(options)) {
             callback = options;
             options = null;
           }
@@ -11273,7 +11273,7 @@ var require_follow_redirects = __commonJS({
     }
     function createErrorType(code, message, baseClass) {
       function CustomError(properties) {
-        if (isFunction2(Error.captureStackTrace)) {
+        if (isFunction3(Error.captureStackTrace)) {
           Error.captureStackTrace(this, this.constructor);
         }
         Object.assign(this, properties || {});
@@ -11308,7 +11308,7 @@ var require_follow_redirects = __commonJS({
     function isString2(value) {
       return typeof value === "string" || value instanceof String;
     }
-    function isFunction2(value) {
+    function isFunction3(value) {
       return typeof value === "function";
     }
     function isBuffer2(value) {
@@ -11354,6 +11354,7 @@ __export(src_exports, {
   MOrder: () => MOrder,
   MOrg: () => MOrg,
   MPaymentMethod: () => MPaymentMethod,
+  MPlantilla: () => MPlantilla,
   MPromoCode: () => MPromoCode,
   MRegion: () => MRegion,
   MRole: () => MRole,
@@ -11391,6 +11392,7 @@ __export(src_exports, {
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
   schemaDivision: () => schemaDivision,
+  schemaPlantilla: () => schemaPlantilla,
   schemaRegion: () => schemaRegion,
   schemaSchool: () => schemaSchool,
   schemaStockCard: () => schemaStockCard,
@@ -11415,6 +11417,7 @@ __export(src_exports, {
   useFileController: () => useFileController,
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
+  useGitHubService: () => useGitHubService,
   useInvoiceController: () => useInvoiceController,
   useInvoiceModel: () => useInvoiceModel,
   useInvoiceRepo: () => useInvoiceRepo,
@@ -11433,6 +11436,8 @@ __export(src_exports, {
   usePaymentModel: () => usePaymentModel,
   usePaymentRepo: () => usePaymentRepo,
   usePaypalService: () => usePaypalService,
+  usePlantillaController: () => usePlantillaController,
+  usePlantillaRepo: () => usePlantillaRepo,
   usePriceController: () => usePriceController,
   usePriceModel: () => usePriceModel,
   usePriceRepo: () => usePriceRepo,
@@ -11455,6 +11460,7 @@ __export(src_exports, {
   useUserController: () => useUserController,
   useUserRepo: () => useUserRepo,
   useUserService: () => useUserService,
+  useUtilController: () => useUtilController,
   useVerificationController: () => useVerificationController,
   useVerificationRepo: () => useVerificationRepo,
   useVerificationService: () => useVerificationService,
@@ -13646,7 +13652,7 @@ var _global = (() => {
 })();
 var isContextDefined = (context) => !isUndefined(context) && context !== _global;
 function merge() {
-  const { caseless } = isContextDefined(this) && this || {};
+  const { caseless, skipUndefined } = isContextDefined(this) && this || {};
   const result = {};
   const assignValue = (val, key) => {
     const targetKey = caseless && findKey(result, key) || key;
@@ -13656,7 +13662,7 @@ function merge() {
       result[targetKey] = merge({}, val);
     } else if (isArray(val)) {
       result[targetKey] = val.slice();
-    } else {
+    } else if (!skipUndefined || !isUndefined(val)) {
       result[targetKey] = val;
     }
   };
@@ -13992,9 +13998,13 @@ AxiosError.from = (error, code, config2, request, response, customProps) => {
   }, (prop) => {
     return prop !== "isAxiosError";
   });
-  AxiosError.call(axiosError, error.message, code, config2, request, response);
-  axiosError.cause = error;
-  axiosError.name = error.name;
+  const msg = error && error.message ? error.message : "Error";
+  const errCode = code == null && error ? error.code : code;
+  AxiosError.call(axiosError, msg, errCode, config2, request, response);
+  if (error && axiosError.cause == null) {
+    Object.defineProperty(axiosError, "cause", { value: error, configurable: true });
+  }
+  axiosError.name = error && error.name || "Error";
   customProps && Object.assign(axiosError, customProps);
   return axiosError;
 };
@@ -14157,7 +14167,7 @@ var AxiosURLSearchParams_default = AxiosURLSearchParams;
 
 // node_modules/axios/lib/helpers/buildURL.js
 function encode2(val) {
-  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+");
 }
 function buildURL(url2, params, options) {
   if (!params) {
@@ -14455,7 +14465,7 @@ var defaults = {
       const silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
       const strictJSONParsing = !silentJSONParsing && JSONRequested;
       try {
-        return JSON.parse(data);
+        return JSON.parse(data, this.parseReviver);
       } catch (e) {
         if (strictJSONParsing) {
           if (e.name === "SyntaxError") {
@@ -14842,7 +14852,7 @@ var import_follow_redirects = __toESM(require_follow_redirects(), 1);
 var import_zlib = __toESM(require("zlib"), 1);
 
 // node_modules/axios/lib/env/data.js
-var VERSION = "1.11.0";
+var VERSION = "1.12.2";
 
 // node_modules/axios/lib/helpers/parseProtocol.js
 function parseProtocol(url2) {
@@ -15241,6 +15251,60 @@ var progressEventDecorator = (total, throttled) => {
 };
 var asyncDecorator = (fn) => (...args) => utils_default.asap(() => fn(...args));
 
+// node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js
+function estimateDataURLDecodedBytes(url2) {
+  if (!url2 || typeof url2 !== "string")
+    return 0;
+  if (!url2.startsWith("data:"))
+    return 0;
+  const comma = url2.indexOf(",");
+  if (comma < 0)
+    return 0;
+  const meta = url2.slice(5, comma);
+  const body = url2.slice(comma + 1);
+  const isBase64 = /;base64/i.test(meta);
+  if (isBase64) {
+    let effectiveLen = body.length;
+    const len = body.length;
+    for (let i = 0; i < len; i++) {
+      if (body.charCodeAt(i) === 37 && i + 2 < len) {
+        const a = body.charCodeAt(i + 1);
+        const b = body.charCodeAt(i + 2);
+        const isHex = (a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102) && (b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102);
+        if (isHex) {
+          effectiveLen -= 2;
+          i += 2;
+        }
+      }
+    }
+    let pad = 0;
+    let idx = len - 1;
+    const tailIsPct3D = (j) => j >= 2 && body.charCodeAt(j - 2) === 37 && // '%'
+    body.charCodeAt(j - 1) === 51 && // '3'
+    (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
+    if (idx >= 0) {
+      if (body.charCodeAt(idx) === 61) {
+        pad++;
+        idx--;
+      } else if (tailIsPct3D(idx)) {
+        pad++;
+        idx -= 3;
+      }
+    }
+    if (pad === 1 && idx >= 0) {
+      if (body.charCodeAt(idx) === 61) {
+        pad++;
+      } else if (tailIsPct3D(idx)) {
+        pad++;
+      }
+    }
+    const groups = Math.floor(effectiveLen / 4);
+    const bytes = groups * 3 - (pad || 0);
+    return bytes > 0 ? bytes : 0;
+  }
+  return Buffer.byteLength(body, "utf8");
+}
+
 // node_modules/axios/lib/adapters/http.js
 var zlibOptions = {
   flush: import_zlib.default.constants.Z_SYNC_FLUSH,
@@ -15384,6 +15448,17 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
     const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : void 0);
     const protocol = parsed.protocol || supportedProtocols[0];
     if (protocol === "data:") {
+      if (config2.maxContentLength > -1) {
+        const dataUrl = String(config2.url || fullPath || "");
+        const estimated = estimateDataURLDecodedBytes(dataUrl);
+        if (estimated > config2.maxContentLength) {
+          return reject(new AxiosError_default(
+            "maxContentLength size of " + config2.maxContentLength + " exceeded",
+            AxiosError_default.ERR_BAD_RESPONSE,
+            config2
+          ));
+        }
+      }
       let convertedData;
       if (method !== "GET") {
         return settle(resolve, reject, {
@@ -15879,13 +15954,17 @@ var resolveConfig_default = (config2) => {
       "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : ""))
     );
   }
-  let contentType;
   if (utils_default.isFormData(data)) {
     if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) {
       headers.setContentType(void 0);
-    } else if ((contentType = headers.getContentType()) !== false) {
-      const [type, ...tokens] = contentType ? contentType.split(";").map((token) => token.trim()).filter(Boolean) : [];
-      headers.setContentType([type || "multipart/form-data", ...tokens].join("; "));
+    } else if (utils_default.isFunction(data.getHeaders)) {
+      const formHeaders = data.getHeaders();
+      const allowedHeaders = ["content-type", "content-length"];
+      Object.entries(formHeaders).forEach(([key, val]) => {
+        if (allowedHeaders.includes(key.toLowerCase())) {
+          headers.set(key, val);
+        }
+      });
     }
   }
   if (platform_default.hasStandardBrowserEnv) {
@@ -15965,8 +16044,11 @@ var xhr_default = isXHRAdapterSupported && function(config2) {
       reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config2, request));
       request = null;
     };
-    request.onerror = function handleError() {
-      reject(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config2, request));
+    request.onerror = function handleError(event) {
+      const msg = event && event.message ? event.message : "Network Error";
+      const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config2, request);
+      err.event = event || null;
+      reject(err);
       request = null;
     };
     request.ontimeout = function handleTimeout() {
@@ -16141,9 +16223,16 @@ var trackStream = (stream4, chunkSize, onProgress, onFinish) => {
 };
 
 // node_modules/axios/lib/adapters/fetch.js
-var isFetchSupported = typeof fetch === "function" && typeof Request === "function" && typeof Response === "function";
-var isReadableStreamSupported = isFetchSupported && typeof ReadableStream === "function";
-var encodeText = isFetchSupported && (typeof TextEncoder === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Response(str).arrayBuffer()));
+var DEFAULT_CHUNK_SIZE = 64 * 1024;
+var { isFunction: isFunction2 } = utils_default;
+var globalFetchAPI = (({ Request, Response }) => ({
+  Request,
+  Response
+}))(utils_default.global);
+var {
+  ReadableStream: ReadableStream2,
+  TextEncoder: TextEncoder2
+} = utils_default.global;
 var test = (fn, ...args) => {
   try {
     return !!fn(...args);
@@ -16151,164 +16240,204 @@ var test = (fn, ...args) => {
     return false;
   }
 };
-var supportsRequestStream = isReadableStreamSupported && test(() => {
-  let duplexAccessed = false;
-  const hasContentType = new Request(platform_default.origin, {
-    body: new ReadableStream(),
-    method: "POST",
-    get duplex() {
-      duplexAccessed = true;
-      return "half";
-    }
-  }).headers.has("Content-Type");
-  return duplexAccessed && !hasContentType;
-});
-var DEFAULT_CHUNK_SIZE = 64 * 1024;
-var supportsResponseStream = isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
-var resolvers = {
-  stream: supportsResponseStream && ((res) => res.body)
-};
-isFetchSupported && ((res) => {
-  ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
-    !resolvers[type] && (resolvers[type] = utils_default.isFunction(res[type]) ? (res2) => res2[type]() : (_, config2) => {
-      throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config2);
-    });
-  });
-})(new Response());
-var getBodyLength = async (body) => {
-  if (body == null) {
-    return 0;
-  }
-  if (utils_default.isBlob(body)) {
-    return body.size;
+var factory = (env) => {
+  env = utils_default.merge.call({
+    skipUndefined: true
+  }, globalFetchAPI, env);
+  const { fetch: envFetch, Request, Response } = env;
+  const isFetchSupported = envFetch ? isFunction2(envFetch) : typeof fetch === "function";
+  const isRequestSupported = isFunction2(Request);
+  const isResponseSupported = isFunction2(Response);
+  if (!isFetchSupported) {
+    return false;
   }
-  if (utils_default.isSpecCompliantForm(body)) {
-    const _request = new Request(platform_default.origin, {
+  const isReadableStreamSupported = isFetchSupported && isFunction2(ReadableStream2);
+  const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder2()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
+  const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+    let duplexAccessed = false;
+    const hasContentType = new Request(platform_default.origin, {
+      body: new ReadableStream2(),
       method: "POST",
-      body
-    });
-    return (await _request.arrayBuffer()).byteLength;
-  }
-  if (utils_default.isArrayBufferView(body) || utils_default.isArrayBuffer(body)) {
-    return body.byteLength;
-  }
-  if (utils_default.isURLSearchParams(body)) {
-    body = body + "";
-  }
-  if (utils_default.isString(body)) {
-    return (await encodeText(body)).byteLength;
-  }
-};
-var resolveBodyLength = async (headers, body) => {
-  const length = utils_default.toFiniteNumber(headers.getContentLength());
-  return length == null ? getBodyLength(body) : length;
-};
-var fetch_default = isFetchSupported && (async (config2) => {
-  let {
-    url: url2,
-    method,
-    data,
-    signal,
-    cancelToken,
-    timeout,
-    onDownloadProgress,
-    onUploadProgress,
-    responseType,
-    headers,
-    withCredentials = "same-origin",
-    fetchOptions
-  } = resolveConfig_default(config2);
-  responseType = responseType ? (responseType + "").toLowerCase() : "text";
-  let composedSignal = composeSignals_default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
-  let request;
-  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
-    composedSignal.unsubscribe();
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
+      }
+    }).headers.has("Content-Type");
+    return duplexAccessed && !hasContentType;
   });
-  let requestContentLength;
-  try {
-    if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
-      let _request = new Request(url2, {
-        method: "POST",
-        body: data,
-        duplex: "half"
+  const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
+  const resolvers = {
+    stream: supportsResponseStream && ((res) => res.body)
+  };
+  isFetchSupported && (() => {
+    ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
+      !resolvers[type] && (resolvers[type] = (res, config2) => {
+        let method = res && res[type];
+        if (method) {
+          return method.call(res);
+        }
+        throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config2);
       });
-      let contentTypeHeader;
-      if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
-        headers.setContentType(contentTypeHeader);
-      }
-      if (_request.body) {
-        const [onProgress, flush] = progressEventDecorator(
-          requestContentLength,
-          progressEventReducer(asyncDecorator(onUploadProgress))
-        );
-        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
-      }
+    });
+  })();
+  const getBodyLength = async (body) => {
+    if (body == null) {
+      return 0;
     }
-    if (!utils_default.isString(withCredentials)) {
-      withCredentials = withCredentials ? "include" : "omit";
+    if (utils_default.isBlob(body)) {
+      return body.size;
     }
-    const isCredentialsSupported = "credentials" in Request.prototype;
-    request = new Request(url2, {
-      ...fetchOptions,
-      signal: composedSignal,
-      method: method.toUpperCase(),
-      headers: headers.normalize().toJSON(),
-      body: data,
-      duplex: "half",
-      credentials: isCredentialsSupported ? withCredentials : void 0
-    });
-    let response = await fetch(request, fetchOptions);
-    const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
-    if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
-      const options = {};
-      ["status", "statusText", "headers"].forEach((prop) => {
-        options[prop] = response[prop];
+    if (utils_default.isSpecCompliantForm(body)) {
+      const _request = new Request(platform_default.origin, {
+        method: "POST",
+        body
       });
-      const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
-      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
-        responseContentLength,
-        progressEventReducer(asyncDecorator(onDownloadProgress), true)
-      ) || [];
-      response = new Response(
-        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
-          flush && flush();
-          unsubscribe && unsubscribe();
-        }),
-        options
-      );
+      return (await _request.arrayBuffer()).byteLength;
     }
-    responseType = responseType || "text";
-    let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config2);
-    !isStreamResponse && unsubscribe && unsubscribe();
-    return await new Promise((resolve, reject) => {
-      settle(resolve, reject, {
-        data: responseData,
-        headers: AxiosHeaders_default.from(response.headers),
-        status: response.status,
-        statusText: response.statusText,
-        config: config2,
-        request
-      });
+    if (utils_default.isArrayBufferView(body) || utils_default.isArrayBuffer(body)) {
+      return body.byteLength;
+    }
+    if (utils_default.isURLSearchParams(body)) {
+      body = body + "";
+    }
+    if (utils_default.isString(body)) {
+      return (await encodeText(body)).byteLength;
+    }
+  };
+  const resolveBodyLength = async (headers, body) => {
+    const length = utils_default.toFiniteNumber(headers.getContentLength());
+    return length == null ? getBodyLength(body) : length;
+  };
+  return async (config2) => {
+    let {
+      url: url2,
+      method,
+      data,
+      signal,
+      cancelToken,
+      timeout,
+      onDownloadProgress,
+      onUploadProgress,
+      responseType,
+      headers,
+      withCredentials = "same-origin",
+      fetchOptions
+    } = resolveConfig_default(config2);
+    let _fetch = envFetch || fetch;
+    responseType = responseType ? (responseType + "").toLowerCase() : "text";
+    let composedSignal = composeSignals_default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+    let request = null;
+    const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+      composedSignal.unsubscribe();
     });
-  } catch (err) {
-    unsubscribe && unsubscribe();
-    if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
-      throw Object.assign(
-        new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config2, request),
-        {
-          cause: err.cause || err
+    let requestContentLength;
+    try {
+      if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
+        let _request = new Request(url2, {
+          method: "POST",
+          body: data,
+          duplex: "half"
+        });
+        let contentTypeHeader;
+        if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
+          headers.setContentType(contentTypeHeader);
         }
-      );
+        if (_request.body) {
+          const [onProgress, flush] = progressEventDecorator(
+            requestContentLength,
+            progressEventReducer(asyncDecorator(onUploadProgress))
+          );
+          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+        }
+      }
+      if (!utils_default.isString(withCredentials)) {
+        withCredentials = withCredentials ? "include" : "omit";
+      }
+      const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
+      const resolvedOptions = {
+        ...fetchOptions,
+        signal: composedSignal,
+        method: method.toUpperCase(),
+        headers: headers.normalize().toJSON(),
+        body: data,
+        duplex: "half",
+        credentials: isCredentialsSupported ? withCredentials : void 0
+      };
+      request = isRequestSupported && new Request(url2, resolvedOptions);
+      let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url2, resolvedOptions));
+      const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
+      if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+        const options = {};
+        ["status", "statusText", "headers"].forEach((prop) => {
+          options[prop] = response[prop];
+        });
+        const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
+        const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+          responseContentLength,
+          progressEventReducer(asyncDecorator(onDownloadProgress), true)
+        ) || [];
+        response = new Response(
+          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+            flush && flush();
+            unsubscribe && unsubscribe();
+          }),
+          options
+        );
+      }
+      responseType = responseType || "text";
+      let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config2);
+      !isStreamResponse && unsubscribe && unsubscribe();
+      return await new Promise((resolve, reject) => {
+        settle(resolve, reject, {
+          data: responseData,
+          headers: AxiosHeaders_default.from(response.headers),
+          status: response.status,
+          statusText: response.statusText,
+          config: config2,
+          request
+        });
+      });
+    } catch (err) {
+      unsubscribe && unsubscribe();
+      if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
+        throw Object.assign(
+          new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config2, request),
+          {
+            cause: err.cause || err
+          }
+        );
+      }
+      throw AxiosError_default.from(err, err && err.code, config2, request);
     }
-    throw AxiosError_default.from(err, err && err.code, config2, request);
-  }
-});
+  };
+};
+var seedCache = /* @__PURE__ */ new Map();
+var getFetch = (config2) => {
+  let env = config2 ? config2.env : {};
+  const { fetch: fetch2, Request, Response } = env;
+  const seeds = [
+    Request,
+    Response,
+    fetch2
+  ];
+  let len = seeds.length, i = len, seed, target, map = seedCache;
+  while (i--) {
+    seed = seeds[i];
+    target = map.get(seed);
+    target === void 0 && map.set(seed, target = i ? /* @__PURE__ */ new Map() : factory(env));
+    map = target;
+  }
+  return target;
+};
+var adapter = getFetch();
 
 // node_modules/axios/lib/adapters/adapters.js
 var knownAdapters = {
   http: http_default,
   xhr: xhr_default,
-  fetch: fetch_default
+  fetch: {
+    get: getFetch
+  }
 };
 utils_default.forEach(knownAdapters, (fn, value) => {
   if (fn) {
@@ -16320,30 +16449,30 @@ utils_default.forEach(knownAdapters, (fn, value) => {
   }
 });
 var renderReason = (reason) => `- ${reason}`;
-var isResolvedHandle = (adapter) => utils_default.isFunction(adapter) || adapter === null || adapter === false;
+var isResolvedHandle = (adapter2) => utils_default.isFunction(adapter2) || adapter2 === null || adapter2 === false;
 var adapters_default = {
-  getAdapter: (adapters) => {
+  getAdapter: (adapters, config2) => {
     adapters = utils_default.isArray(adapters) ? adapters : [adapters];
     const { length } = adapters;
     let nameOrAdapter;
-    let adapter;
+    let adapter2;
     const rejectedReasons = {};
     for (let i = 0; i < length; i++) {
       nameOrAdapter = adapters[i];
       let id;
-      adapter = nameOrAdapter;
+      adapter2 = nameOrAdapter;
       if (!isResolvedHandle(nameOrAdapter)) {
-        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
-        if (adapter === void 0) {
+        adapter2 = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+        if (adapter2 === void 0) {
           throw new AxiosError_default(`Unknown adapter '${id}'`);
         }
       }
-      if (adapter) {
+      if (adapter2 && (utils_default.isFunction(adapter2) || (adapter2 = adapter2.get(config2)))) {
         break;
       }
-      rejectedReasons[id || "#" + i] = adapter;
+      rejectedReasons[id || "#" + i] = adapter2;
     }
-    if (!adapter) {
+    if (!adapter2) {
       const reasons = Object.entries(rejectedReasons).map(
         ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
       );
@@ -16353,7 +16482,7 @@ var adapters_default = {
         "ERR_NOT_SUPPORT"
       );
     }
-    return adapter;
+    return adapter2;
   },
   adapters: knownAdapters
 };
@@ -16377,8 +16506,8 @@ function dispatchRequest(config2) {
   if (["post", "put", "patch"].indexOf(config2.method) !== -1) {
     config2.headers.setContentType("application/x-www-form-urlencoded", false);
   }
-  const adapter = adapters_default.getAdapter(config2.adapter || defaults_default.adapter);
-  return adapter(config2).then(function onAdapterResolution(response) {
+  const adapter2 = adapters_default.getAdapter(config2.adapter || defaults_default.adapter, config2);
+  return adapter2(config2).then(function onAdapterResolution(response) {
     throwIfCancellationRequested(config2);
     response.data = transformData.call(
       config2,
@@ -16584,7 +16713,6 @@ var Axios = class {
     }
     len = requestInterceptorChain.length;
     let newConfig = config2;
-    i = 0;
     while (i < len) {
       const onFulfilled = requestInterceptorChain[i++];
       const onRejected = requestInterceptorChain[i++];
@@ -25650,7 +25778,7 @@ function useRegionService() {
         {
           id: region.toString(),
           name: "Admin",
-          type: "region",
+          type: "basic-edu-ro",
           permissions: ["*"],
           status: "active",
           default: true
@@ -26202,7 +26330,7 @@ function useDivisionService() {
         {
           id: division.toString(),
           name: "Admin",
-          type: "division",
+          type: "basic-edu-sdo",
           permissions: ["*"],
           status: "active",
           default: true
@@ -26306,11 +26434,8 @@ function useDivisionController() {
       return;
     }
     try {
-      const division = await _getById(id);
-      res.json({
-        message: "Successfully retrieved division.",
-        data: { division }
-      });
+      const data = await _getById(id);
+      res.json(data);
       return;
     } catch (error2) {
       next(error2);
@@ -26397,16 +26522,17 @@ var import_joi31 = __toESM(require("joi"));
 var import_mongodb37 = require("mongodb");
 var schemaSchool = import_joi31.default.object({
   _id: import_joi31.default.string().hex().optional().allow("", null),
-  id: import_joi31.default.string().required(),
-  name: import_joi31.default.string().required(),
-  country: import_joi31.default.string().required(),
-  address: import_joi31.default.string().required(),
+  id: import_joi31.default.string().optional().allow("", null),
+  name: import_joi31.default.string().optional().allow("", null),
+  country: import_joi31.default.string().optional().allow("", null),
+  address: import_joi31.default.string().optional().allow("", null),
   continuedAddress: import_joi31.default.string().optional().allow("", null),
-  city: import_joi31.default.string().required(),
-  province: import_joi31.default.string().required(),
-  postalCode: import_joi31.default.string().required(),
-  courses: import_joi31.default.array().items(import_joi31.default.string()).required(),
-  principalName: import_joi31.default.string().required(),
+  city: import_joi31.default.string().required().allow("", null),
+  province: import_joi31.default.string().required().allow("", null),
+  district: import_joi31.default.string().optional().allow("", null),
+  postalCode: import_joi31.default.string().required().allow("", null),
+  courses: import_joi31.default.array().items(import_joi31.default.string()).optional(),
+  principalName: import_joi31.default.string().required().allow("", null),
   principalEmail: import_joi31.default.string().email().optional().allow("", null),
   principalNumber: import_joi31.default.string().optional().allow("", null),
   region: import_joi31.default.string().hex().required(),
@@ -26416,7 +26542,7 @@ var schemaSchool = import_joi31.default.object({
   status: import_joi31.default.string().optional().allow(null, ""),
   createdAt: import_joi31.default.date().optional().allow("", null),
   updatedAt: import_joi31.default.date().optional().allow("", null),
-  createdBy: import_joi31.default.string().hex().required()
+  createdBy: import_joi31.default.string().hex().optional().allow("", null)
 });
 function MSchool(value) {
   const { error } = schemaSchool.validate(value);
@@ -26455,15 +26581,15 @@ function MSchool(value) {
     _id: value._id ? value._id : new import_mongodb37.ObjectId(),
     id: value.id,
     name: value.name,
-    country: value.country,
-    address: value.address,
+    country: value.country ?? "",
+    address: value.address ?? "",
     continuedAddress: value.continuedAddress ?? "",
-    city: value.city,
-    province: value.province,
-    postalCode: value.postalCode,
+    city: value.city ?? "",
+    province: value.province ?? "",
+    postalCode: value.postalCode ?? "",
     courses: value.courses || [],
-    principalName: value.principalName,
-    principalEmail: value.principalEmail,
+    principalName: value.principalName ?? "",
+    principalEmail: value.principalEmail ?? "",
     principalNumber: value.principalNumber ?? "",
     region: value.region,
     regionName: value.regionName ?? "",
@@ -26472,7 +26598,7 @@ function MSchool(value) {
     createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: value.updatedAt ?? "",
     status: value.status ?? "pending",
-    createdBy: value.createdBy
+    createdBy: value.createdBy ?? ""
   };
 }
 
@@ -26740,8 +26866,16 @@ function useSchoolRepo() {
 
 // src/services/school.service.ts
 var import_nodejs_utils64 = require("@eeplatform/nodejs-utils");
+var XLSX = __toESM(require("xlsx"));
+var Papa = __toESM(require("papaparse"));
+var BSON = __toESM(require("bson"));
 function useSchoolService() {
-  const { add, getPendingByCreatedBy, updateStatusById, getPendingById } = useSchoolRepo();
+  const {
+    add: addSchool,
+    getPendingByCreatedBy,
+    updateStatusById,
+    getPendingById
+  } = useSchoolRepo();
   const { addRole } = useRoleRepo();
   const { getUserById } = useUserRepo();
   const { add: addMember } = useMemberRepo();
@@ -26758,7 +26892,7 @@ function useSchoolService() {
     }
     try {
       value.status = "pending";
-      await add(value);
+      await addSchool(value);
       return "Request to register school has been sent successfully. Please wait for approval.";
     } catch (error2) {
       throw error2;
@@ -26777,7 +26911,7 @@ function useSchoolService() {
       session.startTransaction();
       school.status = "approved";
       await updateStatusById(id, "active", session);
-      const roleType = "school";
+      const roleType = "basic-edu-school";
       const roleName = "Admin";
       const roleId = await addRole(
         {
@@ -26822,9 +26956,245 @@ function useSchoolService() {
       await session.endSession();
     }
   }
+  async function add(value) {
+    const { error } = schemaSchool.validate(value);
+    if (error) {
+      throw new import_nodejs_utils64.BadRequestError(error.message);
+    }
+    const session = import_nodejs_utils64.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Unable to start session for school service.");
+    }
+    try {
+      session.startTransaction();
+      value.status = "active";
+      const schoolId = await addSchool(value, session);
+      const roleType = "basic-edu-school";
+      const roleName = "Admin";
+      const roleId = await addRole(
+        {
+          id: schoolId.toString(),
+          type: roleType,
+          name: roleName,
+          permissions: ["*"],
+          status: "active",
+          default: true
+        },
+        session
+      );
+      if (!value.createdBy) {
+        throw new import_nodejs_utils64.BadRequestError("School must have a creator.");
+      }
+      const user = await getUserById(value.createdBy ?? "");
+      if (!user) {
+        throw new import_nodejs_utils64.BadRequestError("User not found for the school creator.");
+      }
+      await addMember(
+        {
+          org: schoolId.toString(),
+          orgName: value.name,
+          user: value.createdBy.toString(),
+          name: `${user.firstName} ${user.lastName}`,
+          role: roleId.toString(),
+          roleName,
+          type: roleType
+        },
+        session
+      );
+      await session.commitTransaction();
+      return "School has been added and activated successfully.";
+    } catch (error2) {
+      import_nodejs_utils64.logger.log({
+        level: "error",
+        message: `Error adding school: ${error2.message}`
+      });
+      await session.abortTransaction();
+      throw error2;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function addBulk(file, region, division) {
+    const MAX_SIZE = 16 * 1024 * 1024;
+    if (file.size > MAX_SIZE) {
+      throw new import_nodejs_utils64.BadRequestError(
+        "File size exceeds 16MB limit. Please use a smaller file to ensure transaction compatibility."
+      );
+    }
+    let schools = [];
+    const validatedSchools = [];
+    const totalSize = validatedSchools.reduce(
+      (sum, school) => sum + BSON.calculateObjectSize(school),
+      0
+    );
+    try {
+      if (file.mimetype.includes("sheet") || file.originalname.endsWith(".xlsx") || file.originalname.endsWith(".xls")) {
+        const workbook = XLSX.read(file.buffer);
+        const sheetName = workbook.SheetNames[0];
+        const worksheet = workbook.Sheets[sheetName];
+        schools = XLSX.utils.sheet_to_json(worksheet);
+      } else if (file.mimetype.includes("csv") || file.originalname.endsWith(".csv")) {
+        const csvText = file.buffer.toString("utf8");
+        const parseResult = Papa.parse(csvText, {
+          header: true,
+          skipEmptyLines: true,
+          transformHeader: (header) => header.trim()
+        });
+        if (parseResult.errors.length > 0) {
+          throw new import_nodejs_utils64.BadRequestError(
+            `CSV parsing error: ${parseResult.errors[0].message}`
+          );
+        }
+        schools = parseResult.data;
+      } else {
+        throw new import_nodejs_utils64.BadRequestError(
+          "Unsupported file type. Please upload an Excel (.xlsx, .xls) or CSV (.csv) file."
+        );
+      }
+      if (!schools || schools.length === 0) {
+        throw new import_nodejs_utils64.BadRequestError("No data found in the uploaded file.");
+      }
+      const errors = [];
+      for (let i = 0; i < schools.length; i++) {
+        const schoolData = schools[i];
+        const rowNumber = i + 1;
+        try {
+          const schoolName = schoolData.schoolName || schoolData.name || "";
+          const schoolId = schoolData.schoolId || schoolData.id || "";
+          const district = schoolData.district || "";
+          if (!schoolName.trim()) {
+            errors.push(`Row ${rowNumber}: School name is required`);
+            continue;
+          }
+          if (!schoolId.trim()) {
+            errors.push(`Row ${rowNumber}: School ID is required`);
+            continue;
+          }
+          if (!district.trim()) {
+            errors.push(`Row ${rowNumber}: District is required`);
+            continue;
+          }
+          const school = {
+            id: schoolId.trim(),
+            name: schoolName.trim(),
+            country: "Philippines",
+            // Default country
+            address: district.trim(),
+            // Use district as address
+            continuedAddress: "",
+            city: district.trim(),
+            // Use district as city
+            province: "",
+            // Will need to be set based on region/division
+            postalCode: "",
+            courses: [],
+            // Empty array for courses
+            principalName: "",
+            principalEmail: "",
+            principalNumber: "",
+            region,
+            regionName: "",
+            // Will be populated from region lookup
+            division,
+            divisionName: "",
+            // Will be populated from division lookup
+            status: "active"
+          };
+          const { error } = schemaSchool.validate(school);
+          if (error) {
+            errors.push(`Row ${rowNumber}: ${error.message}`);
+            continue;
+          }
+          validatedSchools.push(school);
+        } catch (error) {
+          errors.push(
+            `Row ${rowNumber}: ${error.message || "Invalid data format"}`
+          );
+        }
+      }
+      if (errors.length > 0) {
+        throw new import_nodejs_utils64.BadRequestError(
+          `Validation errors found:
+${errors.slice(0, 10).join("\n")}${errors.length > 10 ? `
+... and ${errors.length - 10} more errors` : ""}`
+        );
+      }
+      if (validatedSchools.length === 0) {
+        throw new import_nodejs_utils64.BadRequestError(
+          "No valid school records found after validation."
+        );
+      }
+      if (totalSize > MAX_SIZE) {
+        throw new import_nodejs_utils64.BadRequestError(
+          `Data payload (${Math.round(
+            totalSize / 1024 / 1024
+          )}MB) exceeds MongoDB transaction limit of 16MB. Please reduce the number of records or split into smaller files.`
+        );
+      }
+    } catch (error) {
+      if (error instanceof import_nodejs_utils64.BadRequestError) {
+        throw error;
+      }
+      throw new import_nodejs_utils64.BadRequestError(`File processing error: ${error.message}`);
+    }
+    const session = import_nodejs_utils64.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Unable to start session for bulk school upload.");
+    }
+    try {
+      session.startTransaction();
+      const results = {
+        successful: 0,
+        failed: 0,
+        errors: []
+      };
+      for (const school of validatedSchools) {
+        try {
+          const schoolId = await addSchool(school, session);
+          await addRole(
+            {
+              id: schoolId.toString(),
+              type: "basic-edu-school",
+              name: "Admin",
+              permissions: ["*"],
+              status: "active",
+              default: true
+            },
+            session
+          );
+          results.successful++;
+        } catch (error) {
+          results.failed++;
+          results.errors.push(`School "${school.name}": ${error.message}`);
+        }
+      }
+      await session.commitTransaction();
+      return {
+        message: `Bulk upload completed. ${results.successful} schools added successfully.`,
+        details: {
+          successful: results.successful,
+          failed: results.failed,
+          total: validatedSchools.length,
+          totalSizeMB: Math.round(totalSize / 1024 / 1024 * 100) / 100,
+          errors: results.errors
+        }
+      };
+    } catch (error) {
+      import_nodejs_utils64.logger.log({
+        level: "error",
+        message: `Error in bulk school upload: ${error.message}`
+      });
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
   return {
     register,
-    approve
+    approve,
+    add,
+    addBulk
   };
 }
 
@@ -26833,11 +27203,16 @@ var import_nodejs_utils65 = require("@eeplatform/nodejs-utils");
 var import_joi32 = __toESM(require("joi"));
 function useSchoolController() {
   const {
-    add: _add,
     getAll: _getAll,
     getPendingByCreatedBy: _getPendingByCreatedBy,
     updateStatusById: _updateStatusById
   } = useSchoolRepo();
+  const {
+    add: _addSchool,
+    register: _registerSchool,
+    approve,
+    addBulk: _addBulk
+  } = useSchoolService();
   async function add(req, res, next) {
     const payload = req.body;
     const { error } = schemaSchool.validate(payload);
@@ -26846,8 +27221,8 @@ function useSchoolController() {
       return;
     }
     try {
-      const school = await _add(payload);
-      res.status(201).json(school);
+      const result = await _addSchool(payload);
+      res.status(201).json({ message: result });
       return;
     } catch (error2) {
       next(error2);
@@ -26937,7 +27312,6 @@ function useSchoolController() {
       next(error2);
     }
   }
-  const { register: _registerSchool, approve } = useSchoolService();
   async function registerSchool(req, res, next) {
     const payload = req.body;
     const { error } = schemaSchool.validate(payload);
@@ -26972,13 +27346,38 @@ function useSchoolController() {
       next(error2);
     }
   }
+  async function addBulk(req, res, next) {
+    if (!req.file) {
+      res.status(400).send("File is required!");
+      return;
+    }
+    const { region, division } = req.body;
+    const validation = import_joi32.default.object({
+      region: import_joi32.default.string().hex().required(),
+      division: import_joi32.default.string().hex().required()
+    });
+    const { error } = validation.validate({ region, division });
+    if (error) {
+      next(new import_nodejs_utils65.BadRequestError(`Validation error: ${error.message}`));
+      return;
+    }
+    try {
+      const result = await _addBulk(req.file, region, division);
+      res.status(201).json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
   return {
     add,
     getAll,
     getByCreatedBy,
     updateStatusById,
     registerSchool,
-    approveSchool
+    approveSchool,
+    addBulk
   };
 }
 
@@ -29166,6 +29565,942 @@ function useStockCardController() {
     getSuppliers
   };
 }
+
+// src/services/github.service.ts
+var import_nodejs_utils80 = require("@eeplatform/nodejs-utils");
+var import_rest = require("@octokit/rest");
+var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
+function useGitHubService() {
+  function parseRepoUrl(url2) {
+    const match = url2.match(/github\.com[:\/]([^\/]+)\/(.+)\.git$/);
+    if (!match)
+      throw new Error("Invalid GitHub repo URL");
+    return { owner: match[1], repo: match[2] };
+  }
+  async function checkAdminPermission(owner, repo, octokit) {
+    try {
+      const { data: repoData } = await octokit.repos.get({ owner, repo });
+      if (!repoData.permissions?.admin) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "You do not have admin access to this repository."
+        );
+      }
+    } catch (error) {
+      if (error.status === 404) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "Repository not found or you don't have access to it."
+        );
+      } else if (error.status === 401) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "Invalid GitHub token or insufficient permissions."
+        );
+      } else if (error.message.includes("admin access")) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils80.BadRequestError(
+          `Failed to check repository permissions: ${error.message}`
+        );
+      }
+    }
+  }
+  async function setVariables(params) {
+    try {
+      const { githubToken, repoUrl, environment, type, keyValues } = params;
+      const octokit = new import_rest.Octokit({ auth: githubToken });
+      const { owner, repo } = parseRepoUrl(repoUrl);
+      await checkAdminPermission(owner, repo, octokit);
+      const lines = keyValues.split(/[\n\r\s\t]+/).map((l) => l.trim()).filter(Boolean);
+      for (const line of lines) {
+        const equalIndex = line.indexOf("=");
+        if (equalIndex === -1)
+          continue;
+        const key = line.substring(0, equalIndex).trim();
+        const value = line.substring(equalIndex + 1).trim();
+        if (!key || !value)
+          continue;
+        if (type === "secret") {
+          const { data: publicKeyRes } = await octokit.actions.getEnvironmentPublicKey({
+            owner,
+            repo,
+            environment_name: environment
+          });
+          try {
+            await import_libsodium_wrappers.default.ready;
+            const sodium = import_libsodium_wrappers.default;
+            const publicKeyBase64 = publicKeyRes.key;
+            if (!publicKeyBase64) {
+              throw new Error("No public key received from GitHub");
+            }
+            const keyBytes = new Uint8Array(
+              Buffer.from(publicKeyBase64, "base64")
+            );
+            const valueBytes = new Uint8Array(Buffer.from(value, "utf8"));
+            const encryptedBytes = sodium.crypto_box_seal(valueBytes, keyBytes);
+            const encryptedValue = Buffer.from(encryptedBytes).toString("base64");
+            await octokit.actions.createOrUpdateEnvironmentSecret({
+              owner,
+              repo,
+              environment_name: environment,
+              secret_name: key,
+              encrypted_value: encryptedValue,
+              key_id: publicKeyRes.key_id
+            });
+          } catch (encryptionError) {
+            throw new import_nodejs_utils80.BadRequestError(
+              `Failed to encrypt secret '${key}': ${encryptionError.message}`
+            );
+          }
+        } else if (type === "env") {
+          await octokit.actions.createEnvironmentVariable({
+            owner,
+            repo,
+            environment_name: environment,
+            name: key,
+            value
+          });
+        }
+      }
+      return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils80.AppError)
+        throw error;
+      if (error.status === 422) {
+        throw new import_nodejs_utils80.BadRequestError(
+          `GitHub API validation error: ${error.message}`
+        );
+      } else if (error.status === 404) {
+        throw new import_nodejs_utils80.BadRequestError("Environment or repository not found.");
+      } else if (error.status === 403) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "Forbidden: Insufficient permissions or rate limit exceeded."
+        );
+      } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils80.BadRequestError(
+          `Failed to set GitHub variables: ${error.message}`
+        );
+      }
+    }
+  }
+  return {
+    setVariables
+  };
+}
+
+// src/controllers/util.controller.ts
+var import_joi40 = __toESM(require("joi"));
+var import_nodejs_utils81 = require("@eeplatform/nodejs-utils");
+function useUtilController() {
+  async function healthCheck(req, res, next) {
+    try {
+      res.status(200).json({
+        success: true,
+        message: "Util service is healthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          availableEndpoints: [
+            "POST /github/variables - Set GitHub environment variables or secrets"
+          ],
+          keyValueFormat: "KEY=value pairs separated by newlines, spaces, or tabs"
+        }
+      });
+    } catch (error) {
+      import_nodejs_utils81.logger.error("Health check failed", { error: error.message });
+      next(new import_nodejs_utils81.InternalServerError("Health check failed"));
+    }
+  }
+  async function setGitHubVariables(req, res, next) {
+    try {
+      const { githubToken, repoUrl, environment, type, keyValues } = req.body;
+      const validation = import_joi40.default.object({
+        githubToken: import_joi40.default.string().required().messages({
+          "string.empty": "GitHub token is required",
+          "any.required": "GitHub token is required"
+        }),
+        repoUrl: import_joi40.default.string().uri().required().messages({
+          "string.empty": "Repository URL is required",
+          "string.uri": "Repository URL must be a valid URL",
+          "any.required": "Repository URL is required"
+        }),
+        environment: import_joi40.default.string().required().messages({
+          "string.empty": "Environment name is required",
+          "any.required": "Environment name is required"
+        }),
+        type: import_joi40.default.string().valid("env", "secret").required().messages({
+          "any.only": 'Type must be either "env" or "secret"',
+          "any.required": "Type is required"
+        }),
+        keyValues: import_joi40.default.string().required().messages({
+          "string.empty": "Key-value pairs are required",
+          "any.required": "Key-value pairs are required"
+        })
+      });
+      const { error } = validation.validate({
+        githubToken,
+        repoUrl,
+        environment,
+        type,
+        keyValues
+      });
+      if (error) {
+        next(new import_nodejs_utils81.BadRequestError(error.message));
+        return;
+      }
+      const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
+      if (!repoUrlPattern.test(repoUrl)) {
+        next(
+          new import_nodejs_utils81.BadRequestError(
+            "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
+          )
+        );
+        return;
+      }
+      const lines = keyValues.split(/[\n\r\s\t]+/).map((l) => l.trim()).filter(Boolean);
+      const invalidLines = lines.filter(
+        (line) => !line.includes("=") || line.indexOf("=") === -1
+      );
+      if (invalidLines.length > 0) {
+        next(
+          new import_nodejs_utils81.BadRequestError(
+            "Invalid key-value format. Each pair should be in format: KEY=value. Pairs can be separated by newlines, spaces, or tabs."
+          )
+        );
+        return;
+      }
+      const githubService = useGitHubService();
+      const result = await githubService.setVariables({
+        githubToken,
+        repoUrl,
+        environment,
+        type,
+        keyValues
+      });
+      import_nodejs_utils81.logger.info(`GitHub variables set successfully`, {
+        repoUrl,
+        environment,
+        type,
+        count: lines.length
+      });
+      res.status(200).json({
+        success: true,
+        message: result,
+        data: {
+          repoUrl,
+          environment,
+          type,
+          variablesSet: lines.length
+        }
+      });
+    } catch (error) {
+      import_nodejs_utils81.logger.error("Failed to set GitHub variables", {
+        error: error.message,
+        stack: error.stack
+      });
+      if (error instanceof import_nodejs_utils81.AppError) {
+        next(error);
+      } else {
+        next(
+          new import_nodejs_utils81.InternalServerError(
+            `Failed to set GitHub variables: ${error.message}`
+          )
+        );
+      }
+    }
+  }
+  return {
+    healthCheck,
+    setGitHubVariables
+  };
+}
+
+// src/models/plantilla.model.ts
+var import_nodejs_utils82 = require("@eeplatform/nodejs-utils");
+var import_joi41 = __toESM(require("joi"));
+var import_mongodb46 = require("mongodb");
+var schemaPlantilla = import_joi41.default.object({
+  _id: import_joi41.default.string().hex().optional().allow(null, ""),
+  itemNumber: import_joi41.default.string().required(),
+  positionTitle: import_joi41.default.string().required(),
+  positionCategory: import_joi41.default.string().required(),
+  region: import_joi41.default.string().hex().optional().allow(null, ""),
+  regionName: import_joi41.default.string().optional().allow(null, ""),
+  division: import_joi41.default.string().hex().optional().allow(null, ""),
+  divisionName: import_joi41.default.string().optional().allow(null, ""),
+  salaryGrade: import_joi41.default.number().required(),
+  step: import_joi41.default.number().optional().allow(null, 0),
+  incumbent: import_joi41.default.string().optional().allow(null, ""),
+  annualSalary: import_joi41.default.number().optional().allow(null, 0),
+  monthlySalary: import_joi41.default.number().optional().allow(null, 0),
+  status: import_joi41.default.string().required(),
+  employee: import_joi41.default.string().hex().optional().allow(null, ""),
+  createdAt: import_joi41.default.date().iso().optional().allow(null, ""),
+  updatedAt: import_joi41.default.date().iso().optional().allow(null, ""),
+  deletedAt: import_joi41.default.date().iso().optional().allow(null, "")
+});
+function MPlantilla(data) {
+  const { error } = schemaPlantilla.validate(data);
+  if (error) {
+    throw new import_nodejs_utils82.BadRequestError(error.message);
+  }
+  if (data._id && typeof data._id === "string") {
+    try {
+      data._id = new import_mongodb46.ObjectId(data._id);
+    } catch (error2) {
+      throw new import_nodejs_utils82.BadRequestError("Invalid _id.");
+    }
+  }
+  return {
+    _id: data._id,
+    itemNumber: data.itemNumber ?? "",
+    positionTitle: data.positionTitle ?? "",
+    positionCategory: data.positionCategory ?? "",
+    status: data.status ?? "active",
+    salaryGrade: data.salaryGrade ?? 0,
+    step: data.step ?? 0,
+    monthlySalary: data.monthlySalary ?? 0,
+    annualSalary: data.annualSalary ?? 0,
+    region: data.region ?? "",
+    regionName: data.regionName ?? "",
+    division: data.division ?? "",
+    divisionName: data.divisionName ?? "",
+    incumbent: data.incumbent ?? "",
+    createdAt: data.createdAt ? new Date(data.createdAt) : /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ? new Date(data.updatedAt) : "",
+    deletedAt: data.deletedAt ? new Date(data.deletedAt) : ""
+  };
+}
+
+// src/repositories/plantilla.repository.ts
+var import_nodejs_utils83 = require("@eeplatform/nodejs-utils");
+var import_mongodb47 = require("mongodb");
+function usePlantillaRepo() {
+  const db = import_nodejs_utils83.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "plantillas";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils83.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 }, unique: true, name: "unique_name_index" },
+        { key: { school: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on plantillas.");
+    }
+  }
+  async function add(value, session, clearCache = true) {
+    console.log(value);
+    try {
+      value = MPlantilla(value);
+      const res = await collection.insertOne(value, { session });
+      if (clearCache) {
+        delCachedData();
+      }
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils83.BadRequestError("Plantilla already exists.");
+        }
+        throw new Error("Failed to create plantilla.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils83.BadRequestError("Invalid ID.");
+    }
+    value.updatedAt = /* @__PURE__ */ new Date();
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update plantilla.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    org = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    if (org) {
+      try {
+        query.org = new import_mongodb47.ObjectId(org);
+      } catch (error) {
+        throw new import_nodejs_utils83.BadRequestError("Invalid org ID.");
+      }
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (org)
+      cacheParams.org = org;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils83.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils83.logger.log({
+      level: "info",
+      message: `Cache key for getAll plantillas: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache hit for getAll plantillas: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils83.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache set for getAll plantillas: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils83.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll plantillas: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils83.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils83.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache hit for getById plantilla: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache set for plantilla by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils83.logger.log({
+          level: "error",
+          message: `Failed to set cache for plantilla by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils83.InternalServerError("Failed to get plantilla.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils83.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils83.InternalServerError("Failed to delete plantilla.");
+      }
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils83.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    delCachedData
+  };
+}
+
+// src/controllers/plantilla.controller.ts
+var import_nodejs_utils85 = require("@eeplatform/nodejs-utils");
+var import_joi42 = __toESM(require("joi"));
+
+// src/services/plantilla.service.ts
+var import_nodejs_utils84 = require("@eeplatform/nodejs-utils");
+var XLSX2 = __toESM(require("xlsx"));
+var Papa2 = __toESM(require("papaparse"));
+function usePlantillaService() {
+  const { add: addPlantilla, delCachedData } = usePlantillaRepo();
+  async function addBulk(file, region, division) {
+    import_nodejs_utils84.logger.log({
+      level: "info",
+      message: `Starting plantilla bulk upload. File: ${file.originalname}, Size: ${file.size} bytes`
+    });
+    const MAX_SIZE = 16 * 1024 * 1024;
+    let plantillas = [];
+    let totalSize = 0;
+    let validatedPlantillas = [];
+    if (!file.buffer) {
+      throw new import_nodejs_utils84.BadRequestError("File buffer is empty or corrupted");
+    }
+    try {
+      const fileExtension = file.originalname.split(".").pop()?.toLowerCase();
+      if (fileExtension === "csv") {
+        const csvData = file.buffer.toString("utf-8");
+        totalSize = Buffer.byteLength(csvData, "utf8");
+        const parseResult = Papa2.parse(csvData, {
+          header: true,
+          skipEmptyLines: true,
+          transformHeader: (header) => {
+            return header.toLowerCase().replace(/\s+/g, "").replace(/[^\w]/g, "");
+          }
+        });
+        if (parseResult.errors.length > 0) {
+          throw new import_nodejs_utils84.BadRequestError(
+            `CSV parsing errors: ${parseResult.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        plantillas = parseResult.data;
+      } else if (fileExtension === "xlsx" || fileExtension === "xls") {
+        totalSize = file.buffer.length;
+        const workbook = XLSX2.read(file.buffer, { type: "buffer" });
+        const sheetName = workbook.SheetNames[0];
+        const worksheet = workbook.Sheets[sheetName];
+        plantillas = XLSX2.utils.sheet_to_json(worksheet, {
+          header: 1,
+          defval: ""
+        });
+        if (plantillas.length === 0) {
+          throw new import_nodejs_utils84.BadRequestError("Excel file is empty.");
+        }
+        const headers = plantillas[0];
+        const normalizedHeaders = headers.map(
+          (header) => header.toLowerCase().replace(/\s+/g, "").replace(/[^\w]/g, "")
+        );
+        plantillas = plantillas.slice(1).map((row) => {
+          const obj = {};
+          normalizedHeaders.forEach((header, index) => {
+            obj[header] = row[index] || "";
+          });
+          return obj;
+        });
+      } else {
+        throw new import_nodejs_utils84.BadRequestError(
+          "Unsupported file type. Please upload an Excel (.xlsx, .xls) or CSV (.csv) file."
+        );
+      }
+      if (!plantillas || plantillas.length === 0) {
+        throw new import_nodejs_utils84.BadRequestError("No data found in the uploaded file.");
+      }
+      const errors = [];
+      for (let i = 0; i < plantillas.length; i++) {
+        const plantillaData = plantillas[i];
+        const rowNumber = i + 1;
+        try {
+          const itemNumber = plantillaData.itemnumber || plantillaData.item_number || "";
+          const positionTitle = plantillaData.positiontitle || plantillaData.position_title || plantillaData.title || "";
+          const positionCategory = plantillaData.positioncategory || plantillaData.position_category || "";
+          const status = plantillaData.status || "active";
+          if (!itemNumber.trim()) {
+            errors.push(`Row ${rowNumber}: Item Number is required`);
+            continue;
+          }
+          if (!positionTitle.trim()) {
+            errors.push(`Row ${rowNumber}: Position Title is required`);
+            continue;
+          }
+          if (!positionCategory.trim()) {
+            errors.push(`Row ${rowNumber}: Position Category is required`);
+            continue;
+          }
+          const plantilla = {
+            itemNumber: itemNumber.trim(),
+            positionTitle: positionTitle.trim(),
+            positionCategory: positionCategory.trim(),
+            salaryGrade: parseInt(
+              plantillaData.salarygrade || plantillaData.salary_grade || "1"
+            ) || 1,
+            step: parseInt(plantillaData.step || "1") || 1,
+            status: status.trim() || "active"
+          };
+          if (region)
+            plantilla.region = region;
+          if (division)
+            plantilla.division = division;
+          if (plantillaData.regionname || plantillaData.region_name) {
+            plantilla.regionName = plantillaData.regionname || plantillaData.region_name;
+          }
+          if (plantillaData.divisionname || plantillaData.division_name) {
+            plantilla.divisionName = plantillaData.divisionname || plantillaData.division_name;
+          }
+          if (plantillaData.incumbent) {
+            plantilla.incumbent = plantillaData.incumbent;
+          }
+          if (plantillaData.employee) {
+            plantilla.employee = plantillaData.employee;
+          }
+          if (plantillaData.annualsalary || plantillaData.annual_salary) {
+            plantilla.annualSalary = parseFloat(
+              plantillaData.annualsalary || plantillaData.annual_salary
+            ) || void 0;
+          }
+          if (plantillaData.monthlysalary || plantillaData.monthly_salary) {
+            plantilla.monthlySalary = parseFloat(
+              plantillaData.monthlysalary || plantillaData.monthly_salary
+            ) || void 0;
+          }
+          if (!plantilla.itemNumber || !plantilla.positionTitle || !plantilla.positionCategory) {
+            errors.push(`Row ${rowNumber}: Missing required fields`);
+            continue;
+          }
+          validatedPlantillas.push(plantilla);
+        } catch (error) {
+          errors.push(
+            `Row ${rowNumber}: ${error.message || "Invalid data format"}`
+          );
+        }
+      }
+      if (errors.length > 0) {
+        throw new import_nodejs_utils84.BadRequestError(
+          `Validation errors found:
+${errors.slice(0, 10).join("\n")}${errors.length > 10 ? `
+... and ${errors.length - 10} more errors` : ""}`
+        );
+      }
+      if (validatedPlantillas.length === 0) {
+        throw new import_nodejs_utils84.BadRequestError(
+          "No valid plantilla records found after validation."
+        );
+      }
+      if (totalSize > MAX_SIZE) {
+        throw new import_nodejs_utils84.BadRequestError(
+          `Data payload (${Math.round(
+            totalSize / 1024 / 1024
+          )}MB) exceeds MongoDB transaction limit of 16MB. Please reduce the number of records or split into smaller files.`
+        );
+      }
+    } catch (error) {
+      if (error instanceof import_nodejs_utils84.BadRequestError) {
+        throw error;
+      }
+      throw new import_nodejs_utils84.BadRequestError(`File processing error: ${error.message}`);
+    }
+    const session = import_nodejs_utils84.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Unable to start session for bulk plantilla upload.");
+    }
+    import_nodejs_utils84.logger.log({
+      level: "info",
+      message: `Starting bulk plantilla upload with ${validatedPlantillas.length} records`
+    });
+    try {
+      session.startTransaction();
+      const results = {
+        successful: 0,
+        failed: 0,
+        errors: []
+      };
+      const promises = [];
+      for (let i = 0; i < validatedPlantillas.length; i++) {
+        const plantilla = validatedPlantillas[i];
+        promises.push(addPlantilla(plantilla, session, false));
+      }
+      await Promise.all(promises);
+      await delCachedData();
+      await session.commitTransaction();
+      return {
+        message: `Bulk upload completed. ${results.successful} plantillas added successfully.`,
+        details: {
+          successful: results.successful,
+          failed: results.failed,
+          total: validatedPlantillas.length,
+          totalSizeMB: Math.round(totalSize / 1024 / 1024 * 100) / 100,
+          errors: results.errors
+        }
+      };
+    } catch (error) {
+      import_nodejs_utils84.logger.log({
+        level: "error",
+        message: `Error in bulk plantilla upload: ${error.message}`
+      });
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  return {
+    addBulk
+  };
+}
+
+// src/controllers/plantilla.controller.ts
+function usePlantillaController() {
+  const {
+    add: _addPlantilla,
+    getAll: _getAllPlantillas,
+    getById: _getPlantillaById,
+    updateById: _updatePlantillaById,
+    deleteById: _deletePlantillaById
+  } = usePlantillaRepo();
+  const { addBulk: _addBulk } = usePlantillaService();
+  async function createPlantilla(req, res, next) {
+    const value = req.body;
+    const validation = import_joi42.default.object({
+      itemNumber: import_joi42.default.string().required(),
+      positionTitle: import_joi42.default.string().required(),
+      positionCategory: import_joi42.default.string().required(),
+      status: import_joi42.default.string().required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_nodejs_utils85.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _addPlantilla(value);
+      res.json({ message: "Plantilla created successfully", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAllPlantillas(req, res, next) {
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const org = req.query.org ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils85.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils85.BadRequestError("Invalid limit number."));
+      return;
+    }
+    const validation = import_joi42.default.object({
+      page: import_joi42.default.number().min(1).optional().allow("", null),
+      limit: import_joi42.default.number().min(1).optional().allow("", null),
+      search: import_joi42.default.string().optional().allow("", null),
+      org: import_joi42.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ page, limit, search, org });
+    if (error) {
+      next(new import_nodejs_utils85.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const plantillas = await _getAllPlantillas({
+        search,
+        page,
+        limit,
+        org
+      });
+      res.json(plantillas);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getPlantillaById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi42.default.object({
+      id: import_joi42.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils85.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const plantilla = await _getPlantillaById(id);
+      if (!plantilla) {
+        next(new import_nodejs_utils85.BadRequestError("Plantilla not found."));
+        return;
+      }
+      res.json(plantilla);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updatePlantilla(req, res, next) {
+    const id = req.params.id;
+    const value = req.body;
+    const validation = import_joi42.default.object({
+      id: import_joi42.default.string().hex().required(),
+      employee: import_joi42.default.string().hex().optional().allow(null, ""),
+      status: import_joi42.default.string().optional(),
+      positionTitle: import_joi42.default.string().optional(),
+      positionCategory: import_joi42.default.string().optional()
+    });
+    const { error } = validation.validate({ id, ...value });
+    if (error) {
+      next(new import_nodejs_utils85.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _updatePlantillaById(id, value);
+      if (result.matchedCount === 0) {
+        next(new import_nodejs_utils85.BadRequestError("Plantilla not found."));
+        return;
+      }
+      res.json({ message: "Plantilla updated successfully" });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deletePlantilla(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi42.default.object({
+      id: import_joi42.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils85.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _deletePlantillaById(id);
+      if (result.matchedCount === 0) {
+        next(new import_nodejs_utils85.BadRequestError("Plantilla not found."));
+        return;
+      }
+      res.json({ message: "Plantilla deleted successfully" });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function bulkAddPlantillas(req, res, next) {
+    if (!req.file) {
+      res.status(400).send("File is required!");
+      return;
+    }
+    const { region, division } = req.body;
+    const validation = import_joi42.default.object({
+      region: import_joi42.default.string().hex().optional(),
+      division: import_joi42.default.string().hex().optional()
+    });
+    const { error } = validation.validate({ region, division });
+    if (error) {
+      next(new import_nodejs_utils85.BadRequestError(`Validation error: ${error.message}`));
+      return;
+    }
+    if (!region && !division) {
+      next(
+        new import_nodejs_utils85.BadRequestError(
+          "At least one of region or division must be provided"
+        )
+      );
+      return;
+    }
+    try {
+      const result = await _addBulk(req.file, region, division);
+      res.status(201).json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createPlantilla,
+    getAllPlantillas,
+    getPlantillaById,
+    updatePlantilla,
+    deletePlantilla,
+    bulkAddPlantillas
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -29197,6 +30532,7 @@ function useStockCardController() {
   MOrder,
   MOrg,
   MPaymentMethod,
+  MPlantilla,
   MPromoCode,
   MRegion,
   MRole,
@@ -29234,6 +30570,7 @@ function useStockCardController() {
   schemaBuilding,
   schemaBuildingUnit,
   schemaDivision,
+  schemaPlantilla,
   schemaRegion,
   schemaSchool,
   schemaStockCard,
@@ -29258,6 +30595,7 @@ function useStockCardController() {
   useFileController,
   useFileRepo,
   useFileService,
+  useGitHubService,
   useInvoiceController,
   useInvoiceModel,
   useInvoiceRepo,
@@ -29276,6 +30614,8 @@ function useStockCardController() {
   usePaymentModel,
   usePaymentRepo,
   usePaypalService,
+  usePlantillaController,
+  usePlantillaRepo,
   usePriceController,
   usePriceModel,
   usePriceRepo,
@@ -29298,6 +30638,7 @@ function useStockCardController() {
   useUserController,
   useUserRepo,
   useUserService,
+  useUtilController,
   useVerificationController,
   useVerificationRepo,
   useVerificationService,