autosync_backend2 1.2.17 → 1.2.19

package/dist/index.js

@@ -22792,8 +22792,8 @@ var require_caller = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/slow-redact/index.js
-var require_slow_redact = __commonJS((exports, module) => {
+// node_modules/@pinojs/redact/index.js
+var require_redact = __commonJS((exports, module) => {
   function deepClone2(obj2) {
     if (obj2 === null || typeof obj2 !== "object") {
       return obj2;
@@ -23296,7 +23296,7 @@ var require_symbols = __commonJS((exports, module) => {
 
 // node_modules/pino/lib/redaction.js
 var require_redaction = __commonJS((exports, module) => {
-  var slowRedact = require_slow_redact();
+  var Redact = require_redact();
   var { redactFmtSym, wildcardFirstSym } = require_symbols();
   var rx = /[^.[\]]+|\[([^[\]]*?)\]/g;
   var CENSOR = "[Redacted]";
@@ -23335,7 +23335,7 @@ var require_redaction = __commonJS((exports, module) => {
       return o;
     }, {});
     const result = {
-      [redactFmtSym]: slowRedact({ paths: paths2, censor, serialize, strict, remove })
+      [redactFmtSym]: Redact({ paths: paths2, censor, serialize, strict, remove })
     };
     const topCensor = (...args) => {
       return typeof censor === "function" ? serialize(censor(...args)) : serialize(censor);
@@ -23347,7 +23347,7 @@ var require_redaction = __commonJS((exports, module) => {
         const wrappedCensor = typeof censor === "function" ? (value, path) => {
           return censor(value, [k2, ...path]);
         } : censor;
-        o[k2] = slowRedact({
+        o[k2] = Redact({
           paths: shape[k2],
           censor: wrappedCensor,
           serialize,
@@ -25420,7 +25420,7 @@ var require_levels = __commonJS((exports, module) => {
 
 // node_modules/pino/lib/meta.js
 var require_meta = __commonJS((exports, module) => {
-  module.exports = { version: "9.13.1" };
+  module.exports = { version: "9.14.0" };
 });
 
 // node_modules/pino/lib/proto.js
@@ -25524,6 +25524,7 @@ var require_proto = __commonJS((exports, module) => {
         instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
       }
       instance[chindingsSym] = asChindings(instance, bindings2);
+      instance[setLevelSym](this.level);
       if (this.onChild !== noop2) {
         this.onChild(instance);
       }
@@ -25572,10 +25573,8 @@ var require_proto = __commonJS((exports, module) => {
       instance[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
     }
     instance[chindingsSym] = asChindings(instance, bindings2);
-    if (options.level !== undefined && options.level !== this.level || options.hasOwnProperty("customLevels")) {
-      const childLevel = options.level || this.level;
-      instance[setLevelSym](childLevel);
-    }
+    const childLevel = options.level || this.level;
+    instance[setLevelSym](childLevel);
     this.onChild(instance);
     return instance;
   }
@@ -136200,7 +136199,7 @@ class WithSubquery extends Subquery {
 }
 
 // node_modules/drizzle-orm/version.js
-var version4 = "0.44.6";
+var version4 = "0.44.7";
 
 // node_modules/drizzle-orm/tracing.js
 var otel;
@@ -142404,6 +142403,18 @@ __export(exports_schema, {
   permissionTable: () => permissionTable,
   permissionGroupTable: () => permissionGroupTable,
   logTable: () => logTable,
+  inspectionTemplateTable: () => inspectionTemplateTable,
+  inspectionTemplateMachineKindTable: () => inspectionTemplateMachineKindTable,
+  inspectionTemplateFieldTable: () => inspectionTemplateFieldTable,
+  inspectionTable: () => inspectionTable,
+  inspectionStateResultEnum: () => inspectionStateResultEnum,
+  inspectionStateEnum: () => inspectionStateEnum,
+  inspectionSchema: () => inspectionSchema,
+  inspectionScheduleTable: () => inspectionScheduleTable,
+  inspectionFieldTypeEnum: () => inspectionFieldTypeEnum,
+  inspectionFieldTable: () => inspectionFieldTable,
+  inspectionFieldResult: () => inspectionFieldResult,
+  inspectionFieldGroupTable: () => inspectionFieldGroupTable,
   dataStoreTable: () => dataStoreTable,
   crmVehicleTable: () => crmVehicleTable,
   crmVehicleRelations: () => crmVehicleRelations,
@@ -142926,6 +142937,99 @@ var crmInspectionTable = crmSchema.table("inspections", {
   description: text(),
   status: crmInspectionStatusEnum("status").notNull().default("CREATED")
 });
+// src/lib/db/schema/fleet.schema.ts
+var inspectionSchema = pgSchema("inspection");
+var inspectionFieldGroupTable = inspectionSchema.table("field_group", {
+  ...base_schema_helper_default,
+  code: varchar(),
+  name: varchar().notNull(),
+  description: text()
+});
+var inspectionFieldTypeEnum = inspectionSchema.enum("field_type_enum", ["BOOLEAN", "NUMERIC", "TEXT", "DATE", "RATE", "MULTI_CHOICE"]);
+var inspectionFieldTable = inspectionSchema.table("field", {
+  ...base_schema_helper_default,
+  groupId: uuid5().notNull(),
+  code: varchar(),
+  description: text(),
+  version: varchar(),
+  isActive: boolean4().notNull().default(true),
+  metadata: jsonb(),
+  required: boolean4().notNull().default(false),
+  fieldGroup: varchar(),
+  sortIndex: integer2()
+});
+var inspectionTemplateTable = inspectionSchema.table("template", {
+  ...base_schema_helper_default,
+  companyId: uuid5(),
+  name: varchar().notNull(),
+  description: text(),
+  version: varchar(),
+  isActive: boolean4().notNull().default(true)
+});
+var inspectionTemplateFieldTable = inspectionSchema.table("template_field", {
+  ...base_schema_helper_default,
+  templateId: uuid5().notNull(),
+  fieldGroupId: uuid5(),
+  fieldGroup: varchar(),
+  fieldId: uuid5().notNull(),
+  code: varchar(),
+  description: text(),
+  fieldType: inspectionFieldTypeEnum().notNull(),
+  required: boolean4().notNull().default(false),
+  metadata: jsonb(),
+  sortIndex: integer2()
+});
+var inspectionTemplateMachineKindTable = inspectionSchema.table("template_machine_kind", {
+  templateId: uuid5().notNull(),
+  machineKindId: uuid5().notNull()
+});
+var inspectionStateEnum = inspectionSchema.enum("state", [
+  "CREATED",
+  "SCHEDULED",
+  "IN_PROGRESS",
+  "COMPLETED"
+]);
+var inspectionStateResultEnum = inspectionSchema.enum("state_result", [
+  "NOT_INSPECTED",
+  "PASSED",
+  "FAILED",
+  "RETURNED",
+  "WAIVED"
+]);
+var inspectionTable = inspectionSchema.table("inspection", {
+  ...base_schema_helper_default,
+  machineId: uuid5().notNull(),
+  templateId: uuid5().notNull(),
+  employeeInspectedId: uuid5().notNull(),
+  userInspectedId: uuid5().notNull(),
+  hours: numeric({ mode: "number" }),
+  mileageKm: numeric({ mode: "number" }),
+  state: inspectionStateEnum().notNull().default("CREATED"),
+  stateResult: inspectionStateResultEnum(),
+  timeScheduled: timestamp({
+    withTimezone: true
+  }).notNull(),
+  timeStarted: timestamp({ withTimezone: true }).notNull(),
+  timeCompleted: timestamp({ withTimezone: true }).notNull(),
+  note: text()
+});
+var inspectionFieldResult = inspectionSchema.table("field_result", {
+  ...base_schema_helper_default,
+  inspectionId: uuid5().notNull(),
+  templateFieldId: uuid5().notNull(),
+  result: varchar(),
+  numeric: numeric({ mode: "number" }),
+  comment: varchar(),
+  severityLevel: integer2()
+});
+var inspectionScheduleTable = inspectionSchema.table("schedule", {
+  ...base_schema_helper_default,
+  machineId: uuid5().notNull(),
+  templateId: uuid5().notNull(),
+  daysInterval: integer2(),
+  timeNextDue: timestamp({ withTimezone: true }),
+  isActive: boolean4().notNull().default(true)
+});
 // src/lib/db/schema/techdoc.schema.ts
 var techdocSchema = pgSchema("techdoc");
 var techdocVehicleKindEnum = pgEnum("vehicle_kind_enum", [
@@ -142976,7 +143080,8 @@ var warehouseProductTable = warehouseSchema.table("product", {
   partNumber: varchar().notNull(),
   alias: varchar(),
   companyId: uuid5().notNull(),
-  type: warehouseProductTypeEnum().notNull().default("\u0421\u044D\u043B\u0431\u044D\u0433")
+  type: warehouseProductTypeEnum().notNull().default("\u0421\u044D\u043B\u0431\u044D\u0433"),
+  quantityUnit: integer2().notNull().default(1)
 });
 var warehouseWarehouseTable = warehouseSchema.table("warehouse", {
   ...base_schema_helper_default,
@@ -142990,7 +143095,6 @@ var warehouseItemTable = warehouseSchema.table("item", {
   warehouseId: uuid5().notNull(),
   productId: uuid5().notNull(),
   quantity: numeric({ mode: "number" }).notNull().default(0),
-  quantityUnit: integer2().notNull().default(1),
   safetyStock: numeric({ mode: "number" }).notNull(),
   shelfNumber: varchar(),
   description: text(),
@@ -143042,7 +143146,7 @@ var db_default = db;
 var webCrypto = globalThis.crypto;
 var subtle = webCrypto.subtle;
 
-// node_modules/@upstash/redis/chunk-CXQK4IKU.mjs
+// node_modules/@upstash/redis/chunk-TAJI6TAE.mjs
 var __defProp6 = Object.defineProperty;
 var __export4 = (target, all) => {
   for (var name in all)
@@ -143051,11 +143155,12 @@ var __export4 = (target, all) => {
 var error_exports = {};
 __export4(error_exports, {
   UpstashError: () => UpstashError,
+  UpstashJSONParseError: () => UpstashJSONParseError,
   UrlError: () => UrlError
 });
 var UpstashError = class extends Error {
-  constructor(message2) {
-    super(message2);
+  constructor(message2, options) {
+    super(message2, options);
     this.name = "UpstashError";
   }
 };
@@ -143065,6 +143170,13 @@ var UrlError = class extends Error {
     this.name = "UrlError";
   }
 };
+var UpstashJSONParseError = class extends UpstashError {
+  constructor(body, options) {
+    const truncatedBody = body.length > 200 ? body.slice(0, 200) + "..." : body;
+    super(`Unable to parse response body: ${truncatedBody}`, options);
+    this.name = "UpstashJSONParseError";
+  }
+};
 function parseRecursive(obj2) {
   const parsed = Array.isArray(obj2) ? obj2.map((o) => {
     try {
@@ -143207,7 +143319,13 @@ var HttpClient = class {
       throw error3 ?? new Error("Exhausted all retries");
     }
     if (!res.ok) {
-      const body2 = await res.json();
+      let body2;
+      const rawBody2 = await res.text();
+      try {
+        body2 = JSON.parse(rawBody2);
+      } catch (error22) {
+        throw new UpstashJSONParseError(rawBody2, { cause: error22 });
+      }
       throw new UpstashError(`${body2.error}, command was: ${JSON.stringify(req.body)}`);
     }
     if (this.readYourWrites) {
@@ -143245,7 +143363,13 @@ var HttpClient = class {
       })();
       return { result: 1 };
     }
-    const body = await res.json();
+    let body;
+    const rawBody = await res.text();
+    try {
+      body = JSON.parse(rawBody);
+    } catch (error22) {
+      throw new UpstashJSONParseError(rawBody, { cause: error22 });
+    }
     if (this.readYourWrites) {
       const headers = res.headers;
       this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
@@ -145829,7 +145953,7 @@ var Redis = class {
   zunion = (...args) => new ZUnionCommand(args, this.opts).exec(this.client);
   zunionstore = (...args) => new ZUnionStoreCommand(args, this.opts).exec(this.client);
 };
-var VERSION = "v1.35.5";
+var VERSION = "v1.35.6";
 
 // node_modules/@upstash/redis/nodejs.mjs
 if (typeof atob === "undefined") {
@@ -149093,13 +149217,21 @@ class HTTPError extends Error {
   }
 }
 
-// node_modules/ky/distribution/errors/TimeoutError.js
-class TimeoutError extends Error {
-  request;
-  constructor(request) {
-    super(`Request timed out: ${request.method} ${request.url}`);
-    this.name = "TimeoutError";
-    this.request = request;
+// node_modules/ky/distribution/errors/NonError.js
+class NonError extends Error {
+  name = "NonError";
+  value;
+  constructor(value) {
+    let message2 = "Non-error value was thrown";
+    try {
+      if (typeof value === "string") {
+        message2 = value;
+      } else if (value && typeof value === "object" && "message" in value && typeof value.message === "string") {
+        message2 = value.message;
+      }
+    } catch {}
+    super(message2);
+    this.value = value;
   }
 }
 
@@ -149160,7 +149292,11 @@ var kyOptionKeys = {
   throwHttpErrors: true,
   onDownloadProgress: true,
   onUploadProgress: true,
-  fetch: true
+  fetch: true,
+  context: true
+};
+var vendorSpecificOptions = {
+  next: true
 };
 var requestOptionsRegistry = {
   method: true,
@@ -149176,9 +149312,7 @@ var requestOptionsRegistry = {
   keepalive: true,
   signal: true,
   window: true,
-  dispatcher: true,
-  duplex: true,
-  priority: true
+  duplex: true
 };
 
 // node_modules/ky/distribution/utils/body.js
@@ -149255,7 +149389,7 @@ var streamResponse2 = (response, onDownloadProgress) => {
       headers: response.headers
     });
   }
-  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  const totalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
   return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
     status: response.status,
     statusText: response.statusText,
@@ -149307,10 +149441,44 @@ var mergeHooks = (original = {}, incoming = {}) => ({
   afterResponse: newHookValue(original, incoming, "afterResponse"),
   beforeError: newHookValue(original, incoming, "beforeError")
 });
+var appendSearchParameters = (target, source) => {
+  const result = new URLSearchParams;
+  for (const input of [target, source]) {
+    if (input === undefined) {
+      continue;
+    }
+    if (input instanceof URLSearchParams) {
+      for (const [key, value] of input.entries()) {
+        result.append(key, value);
+      }
+    } else if (Array.isArray(input)) {
+      for (const pair of input) {
+        if (!Array.isArray(pair) || pair.length !== 2) {
+          throw new TypeError("Array search parameters must be provided in [[key, value], ...] format");
+        }
+        result.append(String(pair[0]), String(pair[1]));
+      }
+    } else if (isObject6(input)) {
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined) {
+          result.append(key, String(value));
+        }
+      }
+    } else {
+      const parameters = new URLSearchParams(input);
+      for (const [key, value] of parameters.entries()) {
+        result.append(key, value);
+      }
+    }
+  }
+  return result;
+};
 var deepMerge = (...sources) => {
   let returnValue = {};
   let headers = {};
   let hooks = {};
+  let searchParameters;
+  const signals = [];
   for (const source of sources) {
     if (Array.isArray(source)) {
       if (!Array.isArray(returnValue)) {
@@ -149319,6 +149487,28 @@ var deepMerge = (...sources) => {
       returnValue = [...returnValue, ...source];
     } else if (isObject6(source)) {
       for (let [key, value] of Object.entries(source)) {
+        if (key === "signal" && value instanceof globalThis.AbortSignal) {
+          signals.push(value);
+          continue;
+        }
+        if (key === "context") {
+          if (value !== undefined && value !== null && (!isObject6(value) || Array.isArray(value))) {
+            throw new TypeError("The `context` option must be an object");
+          }
+          returnValue = {
+            ...returnValue,
+            context: value === undefined || value === null ? {} : { ...returnValue.context, ...value }
+          };
+          continue;
+        }
+        if (key === "searchParams") {
+          if (value === undefined || value === null) {
+            searchParameters = undefined;
+          } else {
+            searchParameters = searchParameters === undefined ? value : appendSearchParameters(searchParameters, value);
+          }
+          continue;
+        }
         if (isObject6(value) && key in returnValue) {
           value = deepMerge(returnValue[key], value);
         }
@@ -149334,6 +149524,21 @@ var deepMerge = (...sources) => {
       }
     }
   }
+  if (searchParameters !== undefined) {
+    returnValue.searchParams = searchParameters;
+  }
+  if (signals.length > 0) {
+    if (signals.length === 1) {
+      returnValue.signal = signals[0];
+    } else if (supportsAbortSignal) {
+      returnValue.signal = AbortSignal.any(signals);
+    } else {
+      returnValue.signal = signals.at(-1);
+    }
+  }
+  if (returnValue.context === undefined) {
+    returnValue.context = {};
+  }
   return returnValue;
 };
 
@@ -149349,7 +149554,9 @@ var defaultRetryOptions = {
   afterStatusCodes: retryAfterStatusCodes,
   maxRetryAfter: Number.POSITIVE_INFINITY,
   backoffLimit: Number.POSITIVE_INFINITY,
-  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1000
+  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1000,
+  jitter: undefined,
+  retryOnTimeout: false
 };
 var normalizeRetryOptions = (retry = {}) => {
   if (typeof retry === "number") {
@@ -149370,6 +149577,16 @@ var normalizeRetryOptions = (retry = {}) => {
   };
 };
 
+// node_modules/ky/distribution/errors/TimeoutError.js
+class TimeoutError extends Error {
+  request;
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+}
+
 // node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init2, abortController, options) {
   return new Promise((resolve, reject) => {
@@ -149407,7 +149624,10 @@ async function delay(ms2, { signal }) {
 var findUnknownOptions = (request, options) => {
   const unknownOptions = {};
   for (const key in options) {
-    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
+    if (!Object.hasOwn(options, key)) {
+      continue;
+    }
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || (key in vendorSpecificOptions))) {
       unknownOptions[key] = options[key];
     }
   }
@@ -149432,44 +149652,52 @@ var hasSearchParameters = (search) => {
   return Boolean(search);
 };
 
+// node_modules/ky/distribution/utils/type-guards.js
+function isHTTPError(error3) {
+  return error3 instanceof HTTPError || error3?.name === HTTPError.name;
+}
+function isTimeoutError(error3) {
+  return error3 instanceof TimeoutError || error3?.name === TimeoutError.name;
+}
+
 // node_modules/ky/distribution/core/Ky.js
 class Ky {
   static create(input, options) {
     const ky = new Ky(input, options);
     const function_ = async () => {
-      if (typeof ky._options.timeout === "number" && ky._options.timeout > maxSafeTimeout) {
+      if (typeof ky.#options.timeout === "number" && ky.#options.timeout > maxSafeTimeout) {
         throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
       }
       await Promise.resolve();
-      let response = await ky._fetch();
-      for (const hook of ky._options.hooks.afterResponse) {
-        const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
+      let response = await ky.#fetch();
+      for (const hook of ky.#options.hooks.afterResponse) {
+        const modifiedResponse = await hook(ky.request, ky.#getNormalizedOptions(), ky.#decorateResponse(response.clone()), { retryCount: ky.#retryCount });
         if (modifiedResponse instanceof globalThis.Response) {
           response = modifiedResponse;
         }
       }
-      ky._decorateResponse(response);
-      if (!response.ok && ky._options.throwHttpErrors) {
-        let error3 = new HTTPError(response, ky.request, ky._options);
-        for (const hook of ky._options.hooks.beforeError) {
-          error3 = await hook(error3);
+      ky.#decorateResponse(response);
+      if (!response.ok && ky.#options.throwHttpErrors) {
+        let error3 = new HTTPError(response, ky.request, ky.#getNormalizedOptions());
+        for (const hook of ky.#options.hooks.beforeError) {
+          error3 = await hook(error3, { retryCount: ky.#retryCount });
         }
         throw error3;
       }
-      if (ky._options.onDownloadProgress) {
-        if (typeof ky._options.onDownloadProgress !== "function") {
+      if (ky.#options.onDownloadProgress) {
+        if (typeof ky.#options.onDownloadProgress !== "function") {
           throw new TypeError("The `onDownloadProgress` option must be a function");
         }
         if (!supportsResponseStreams) {
           throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
         }
-        return streamResponse2(response.clone(), ky._options.onDownloadProgress);
+        return streamResponse2(response.clone(), ky.#options.onDownloadProgress);
       }
       return response;
     };
-    const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
-    const result = (isRetriableMethod ? ky._retry(function_) : function_()).finally(async () => {
-      const originalRequest = ky._originalRequest;
+    const isRetriableMethod = ky.#options.retry.methods.includes(ky.request.method.toLowerCase());
+    const result = (isRetriableMethod ? ky.#retry(function_) : function_()).finally(async () => {
+      const originalRequest = ky.#originalRequest;
       const cleanupPromises = [];
       if (originalRequest && !originalRequest.bodyUsed) {
         cleanupPromises.push(originalRequest.body?.cancel());
@@ -149511,65 +149739,69 @@ class Ky {
     return searchParams;
   }
   request;
-  abortController;
-  _retryCount = 0;
-  _input;
-  _options;
-  _originalRequest;
+  #abortController;
+  #retryCount = 0;
+  #input;
+  #options;
+  #originalRequest;
+  #userProvidedAbortSignal;
+  #cachedNormalizedOptions;
   constructor(input, options = {}) {
-    this._input = input;
-    this._options = {
+    this.#input = input;
+    this.#options = {
       ...options,
-      headers: mergeHeaders2(this._input.headers, options.headers),
+      headers: mergeHeaders2(this.#input.headers, options.headers),
       hooks: mergeHooks({
         beforeRequest: [],
         beforeRetry: [],
         beforeError: [],
         afterResponse: []
       }, options.hooks),
-      method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
+      method: normalizeRequestMethod(options.method ?? this.#input.method ?? "GET"),
       prefixUrl: String(options.prefixUrl || ""),
       retry: normalizeRetryOptions(options.retry),
       throwHttpErrors: options.throwHttpErrors !== false,
       timeout: options.timeout ?? 1e4,
-      fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+      fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+      context: options.context ?? {}
     };
-    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+    if (typeof this.#input !== "string" && !(this.#input instanceof URL || this.#input instanceof globalThis.Request)) {
       throw new TypeError("`input` must be a string, URL, or Request");
     }
-    if (this._options.prefixUrl && typeof this._input === "string") {
-      if (this._input.startsWith("/")) {
+    if (this.#options.prefixUrl && typeof this.#input === "string") {
+      if (this.#input.startsWith("/")) {
         throw new Error("`input` must not begin with a slash when using `prefixUrl`");
       }
-      if (!this._options.prefixUrl.endsWith("/")) {
-        this._options.prefixUrl += "/";
+      if (!this.#options.prefixUrl.endsWith("/")) {
+        this.#options.prefixUrl += "/";
       }
-      this._input = this._options.prefixUrl + this._input;
+      this.#input = this.#options.prefixUrl + this.#input;
     }
     if (supportsAbortController && supportsAbortSignal) {
-      const originalSignal = this._options.signal ?? this._input.signal;
-      this.abortController = new globalThis.AbortController;
-      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+      this.#userProvidedAbortSignal = this.#options.signal ?? this.#input.signal;
+      this.#abortController = new globalThis.AbortController;
+      this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
     }
     if (supportsRequestStreams) {
-      this._options.duplex = "half";
+      this.#options.duplex = "half";
     }
-    if (this._options.json !== undefined) {
-      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
-      this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
+    if (this.#options.json !== undefined) {
+      this.#options.body = this.#options.stringifyJson?.(this.#options.json) ?? JSON.stringify(this.#options.json);
+      this.#options.headers.set("content-type", this.#options.headers.get("content-type") ?? "application/json");
     }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (hasSearchParameters(this._options.searchParams)) {
-      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this._options.searchParams)).toString();
+    const userProvidedContentType = options.headers && new globalThis.Headers(options.headers).has("content-type");
+    if (this.#input instanceof globalThis.Request && (supportsFormData && this.#options.body instanceof globalThis.FormData || this.#options.body instanceof URLSearchParams) && !userProvidedContentType) {
+      this.#options.headers.delete("content-type");
+    }
+    this.request = new globalThis.Request(this.#input, this.#options);
+    if (hasSearchParameters(this.#options.searchParams)) {
+      const textSearchParams = typeof this.#options.searchParams === "string" ? this.#options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this.#options.searchParams)).toString();
       const searchParams = "?" + textSearchParams;
       const url2 = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
-        this.request.headers.delete("content-type");
-      }
-      this.request = new globalThis.Request(new globalThis.Request(url2, { ...this.request }), this._options);
+      this.request = new globalThis.Request(new globalThis.Request(url2, { ...this.request }), this.#options);
     }
-    if (this._options.onUploadProgress) {
-      if (typeof this._options.onUploadProgress !== "function") {
+    if (this.#options.onUploadProgress) {
+      if (typeof this.#options.onUploadProgress !== "function") {
         throw new TypeError("The `onUploadProgress` option must be a function");
       }
       if (!supportsRequestStreams) {
@@ -149577,69 +149809,106 @@ class Ky {
       }
       const originalBody = this.request.body;
       if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
+        this.request = streamRequest(this.request, this.#options.onUploadProgress, this.#options.body);
+      }
+    }
+  }
+  #calculateDelay() {
+    const retryDelay = this.#options.retry.delay(this.#retryCount);
+    let jitteredDelay = retryDelay;
+    if (this.#options.retry.jitter === true) {
+      jitteredDelay = Math.random() * retryDelay;
+    } else if (typeof this.#options.retry.jitter === "function") {
+      jitteredDelay = this.#options.retry.jitter(retryDelay);
+      if (!Number.isFinite(jitteredDelay) || jitteredDelay < 0) {
+        jitteredDelay = retryDelay;
       }
     }
+    return Math.min(this.#options.retry.backoffLimit, jitteredDelay);
   }
-  _calculateRetryDelay(error3) {
-    this._retryCount++;
-    if (this._retryCount > this._options.retry.limit || error3 instanceof TimeoutError) {
+  async#calculateRetryDelay(error3) {
+    this.#retryCount++;
+    if (this.#retryCount > this.#options.retry.limit) {
+      throw error3;
+    }
+    const errorObject = error3 instanceof Error ? error3 : new NonError(error3);
+    if (this.#options.retry.shouldRetry !== undefined) {
+      const result = await this.#options.retry.shouldRetry({ error: errorObject, retryCount: this.#retryCount });
+      if (result === false) {
+        throw error3;
+      }
+      if (result === true) {
+        return this.#calculateDelay();
+      }
+    }
+    if (isTimeoutError(error3) && !this.#options.retry.retryOnTimeout) {
       throw error3;
     }
-    if (error3 instanceof HTTPError) {
-      if (!this._options.retry.statusCodes.includes(error3.response.status)) {
+    if (isHTTPError(error3)) {
+      if (!this.#options.retry.statusCodes.includes(error3.response.status)) {
         throw error3;
       }
-      const retryAfter = error3.response.headers.get("Retry-After") ?? error3.response.headers.get("RateLimit-Reset") ?? error3.response.headers.get("X-RateLimit-Reset") ?? error3.response.headers.get("X-Rate-Limit-Reset");
-      if (retryAfter && this._options.retry.afterStatusCodes.includes(error3.response.status)) {
+      const retryAfter = error3.response.headers.get("Retry-After") ?? error3.response.headers.get("RateLimit-Reset") ?? error3.response.headers.get("X-RateLimit-Retry-After") ?? error3.response.headers.get("X-RateLimit-Reset") ?? error3.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this.#options.retry.afterStatusCodes.includes(error3.response.status)) {
         let after = Number(retryAfter) * 1000;
         if (Number.isNaN(after)) {
           after = Date.parse(retryAfter) - Date.now();
         } else if (after >= Date.parse("2024-01-01")) {
           after -= Date.now();
         }
-        const max2 = this._options.retry.maxRetryAfter ?? after;
+        const max2 = this.#options.retry.maxRetryAfter ?? after;
         return after < max2 ? after : max2;
       }
       if (error3.response.status === 413) {
         throw error3;
       }
     }
-    const retryDelay = this._options.retry.delay(this._retryCount);
-    return Math.min(this._options.retry.backoffLimit, retryDelay);
+    return this.#calculateDelay();
   }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = async () => this._options.parseJson(await response.text());
+  #decorateResponse(response) {
+    if (this.#options.parseJson) {
+      response.json = async () => this.#options.parseJson(await response.text());
     }
     return response;
   }
-  async _retry(function_) {
+  async#retry(function_) {
     try {
       return await function_();
     } catch (error3) {
-      const ms2 = Math.min(this._calculateRetryDelay(error3), maxSafeTimeout);
-      if (this._retryCount < 1) {
+      const ms2 = Math.min(await this.#calculateRetryDelay(error3), maxSafeTimeout);
+      if (this.#retryCount < 1) {
         throw error3;
       }
-      await delay(ms2, { signal: this._options.signal });
-      for (const hook of this._options.hooks.beforeRetry) {
+      await delay(ms2, this.#userProvidedAbortSignal ? { signal: this.#userProvidedAbortSignal } : {});
+      for (const hook of this.#options.hooks.beforeRetry) {
         const hookResult = await hook({
           request: this.request,
-          options: this._options,
+          options: this.#getNormalizedOptions(),
           error: error3,
-          retryCount: this._retryCount
+          retryCount: this.#retryCount
         });
+        if (hookResult instanceof globalThis.Request) {
+          this.request = hookResult;
+          break;
+        }
+        if (hookResult instanceof globalThis.Response) {
+          return hookResult;
+        }
         if (hookResult === stop) {
           return;
         }
       }
-      return this._retry(function_);
+      return this.#retry(function_);
     }
   }
-  async _fetch() {
-    for (const hook of this._options.hooks.beforeRequest) {
-      const result = await hook(this.request, this._options);
+  async#fetch() {
+    if (this.#abortController?.signal.aborted) {
+      this.#abortController = new globalThis.AbortController;
+      this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
+      this.request = new globalThis.Request(this.request, { signal: this.#options.signal });
+    }
+    for (const hook of this.#options.hooks.beforeRequest) {
+      const result = await hook(this.request, this.#getNormalizedOptions(), { retryCount: this.#retryCount });
       if (result instanceof Request) {
         this.request = result;
         break;
@@ -149648,13 +149917,20 @@ class Ky {
         return result;
       }
     }
-    const nonRequestOptions = findUnknownOptions(this.request, this._options);
-    this._originalRequest = this.request;
-    this.request = this._originalRequest.clone();
-    if (this._options.timeout === false) {
-      return this._options.fetch(this._originalRequest, nonRequestOptions);
+    const nonRequestOptions = findUnknownOptions(this.request, this.#options);
+    this.#originalRequest = this.request;
+    this.request = this.#originalRequest.clone();
+    if (this.#options.timeout === false) {
+      return this.#options.fetch(this.#originalRequest, nonRequestOptions);
     }
-    return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
+    return timeout(this.#originalRequest, nonRequestOptions, this.#abortController, this.#options);
+  }
+  #getNormalizedOptions() {
+    if (!this.#cachedNormalizedOptions) {
+      const { hooks, ...normalizedOptions } = this.#options;
+      this.#cachedNormalizedOptions = Object.freeze(normalizedOptions);
+    }
+    return this.#cachedNormalizedOptions;
   }
 }
 
@@ -149834,7 +150110,12 @@ var CrmVehicleLogic;
       yearImport: new Date(atutData.imported_date).getFullYear(),
       engineCode: atutData.engine_model_name
     };
-    const [result] = await tdb.insert(crmVehicleTable).values(insertData).returning();
+    const [result] = await tdb.insert(crmVehicleTable).values(insertData).onConflictDoUpdate({
+      target: crmVehicleTable.vin,
+      set: {
+        licensePlate: insertData.licensePlate
+      }
+    }).returning();
     return result;
   };
   CrmVehicleLogic.select = async (query, user2) => {
@@ -151329,7 +151610,8 @@ var CrmCpOrderModel;
       type: t.UnionEnum(crmCpOrderTypeEnum.enumValues, {
         default: "Service"
       }),
-      oldId: t.Number()
+      oldId: t.Number(),
+      isPaid: t.Boolean()
     }))
   ]);
   CrmCpOrderModel.complete = t.Object({
@@ -151861,6 +152143,41 @@ var CrmInspectionLogic;
     }).from(crmInspectionTable).where(eq(crmInspectionTable.licensePlate, licensePlate)).leftJoin(companyCompanyTable, eq(companyCompanyTable.id, crmInspectionTable.companyId)).leftJoin(crmVehicleTable, eq(crmVehicleTable.id, crmInspectionTable.vehicleId)).leftJoin(techdocVehicleKindTable, eq(techdocVehicleKindTable.id, crmVehicleTable.vehicleKindId)).leftJoin(companyEmployeeTable, eq(companyEmployeeTable.id, crmInspectionTable.employeeId)).orderBy(desc(crmInspectionTable.createdAt));
     return inspections;
   };
+  CrmInspectionLogic.selectAdmin = async (query) => {
+    const baseQuery = db_default.select({
+      company: {
+        id: companyCompanyTable.id,
+        name: companyCompanyTable.name,
+        serviceName: companyCompanyTable.serviceName,
+        logoUrl: companyCompanyTable.logoUrl
+      },
+      vehicle: {
+        licensePlate: crmVehicleTable.licensePlate,
+        vin: crmVehicleTable.vin,
+        model: techdocVehicleKindTable.name
+      },
+      employee: {
+        firstname: companyEmployeeTable.firstname,
+        lastname: companyEmployeeTable.lastname
+      },
+      inspection: {
+        inspection: crmInspectionTable.inspection,
+        createdAt: crmInspectionTable.createdAt,
+        expireAt: crmInspectionTable.expireAt,
+        status: crmInspectionTable.status
+      },
+      totalCount: totalCountSql
+    }).from(crmInspectionTable).where(eq(crmInspectionTable.companyId, query.companyId).if(query.companyId)).leftJoin(companyCompanyTable, eq(companyCompanyTable.id, crmInspectionTable.companyId)).leftJoin(crmVehicleTable, eq(crmVehicleTable.id, crmInspectionTable.vehicleId)).leftJoin(techdocVehicleKindTable, eq(techdocVehicleKindTable.id, crmVehicleTable.vehicleKindId)).leftJoin(companyEmployeeTable, eq(companyEmployeeTable.id, crmInspectionTable.employeeId)).orderBy(desc(crmInspectionTable.createdAt)).$dynamic();
+    const result = await pagination_helper_default(baseQuery, query.pagination);
+    const content = {
+      totalCount: result[0]?.totalCount ?? 0,
+      totalPage: result.length === 0 ? 0 : Math.ceil(result[0].totalCount / query.pagination.size)
+    };
+    return {
+      result,
+      ...content
+    };
+  };
 })(CrmInspectionLogic ||= {});
 var logic_default17 = CrmInspectionLogic;
 
@@ -151893,6 +152210,12 @@ var CrmInspectionModel;
   CrmInspectionModel.selectUbCab = t.Object({
     licensePlate: t.String()
   });
+  CrmInspectionModel.selectAdmin = t.Composite([
+    t.Partial(t.Object({
+      companyId: t.String({ format: "uuid" })
+    })),
+    PaginationSchema
+  ]);
 })(CrmInspectionModel ||= {});
 var model_default13 = CrmInspectionModel;
 
@@ -151907,6 +152230,9 @@ var inspectionRoutes = new Elysia({
   query: model_default13.select
 }).post("/", async ({ body, user: user2 }) => logic_default17.create(body, user2), {
   body: model_default13.create
+}).get("/admin", async ({ query }) => logic_default17.selectAdmin(query), {
+  query: model_default13.selectAdmin,
+  userKind: "ADMIN"
 }).guard({
   params: IdSchema
 }).get("/:id", async ({ params: { id }, user: user2 }) => logic_default17.getById(id, user2)).post("/:id", async ({ params: { id }, user: user2 }) => logic_default17.approve(id, user2)).put("/:id", async ({ params: { id }, user: user2 }) => logic_default17.cancel(id, user2)).post("/:id/service-order", async ({ params: { id }, user: user2 }) => logic_default17.createCpOrder(id, user2));
@@ -153555,10 +153881,110 @@ var warehouseSchemaRoutes = new Elysia({
 }).use(product_default3).use(warehouse_default).use(item_default3);
 var warehouse_default2 = warehouseSchemaRoutes;
 
+// src/routes/fleet/inspection/field/logic.ts
+var InspectionFieldLogic;
+((InspectionFieldLogic) => {
+  InspectionFieldLogic.select = async (groupId) => {
+    const result = await db_default.select().from(inspectionFieldTable).where(eq(inspectionFieldTable.groupId, groupId));
+    return result;
+  };
+  InspectionFieldLogic.create = async (body) => {
+    await db_default.insert(inspectionFieldTable).values(body);
+  };
+  InspectionFieldLogic.update = async (id, body) => {
+    await db_default.update(inspectionFieldTable).set(body).where(eq(inspectionFieldTable.id, id));
+  };
+  InspectionFieldLogic.remove = async (id) => {
+    await db_default.update(inspectionFieldTable).set({
+      deletedAt: sql3`now()`
+    }).where(eq(inspectionFieldTable.id, id));
+  };
+})(InspectionFieldLogic ||= {});
+var logic_default25 = InspectionFieldLogic;
+
+// src/routes/fleet/inspection/fieldGroup/logic.ts
+var InspectionFieldGroupLogic;
+((InspectionFieldGroupLogic) => {
+  InspectionFieldGroupLogic.select = async (query) => {
+    const filter = and(softDeletedFilter(inspectionFieldGroupTable), ilike(inspectionFieldGroupTable.name, `%${query.name}%`).if(query.name), ilike(inspectionFieldGroupTable.code, `%${query.code}%`).if(query.code));
+    const columns = getTableColumns(inspectionFieldGroupTable);
+    const baseQuery = db_default.select({
+      ...columns,
+      totalCount: totalCountSql
+    }).from(inspectionFieldGroupTable).where(filter).$dynamic();
+    const result = await pagination_helper_default(baseQuery, query.pagination);
+    const content = {
+      totalCount: result[0]?.totalCount ?? 0,
+      totalPage: result.length === 0 ? 0 : Math.ceil(result[0].totalCount / query.pagination.size)
+    };
+    return {
+      result,
+      ...content
+    };
+  };
+  InspectionFieldGroupLogic.create = async (body) => {
+    await db_default.insert(inspectionFieldGroupTable).values(body);
+  };
+  InspectionFieldGroupLogic.update = async (id, body) => {
+    await db_default.update(inspectionFieldGroupTable).set(body).where(eq(inspectionFieldGroupTable.id, id));
+  };
+  InspectionFieldGroupLogic.remove = async (id) => {
+    await db_default.update(inspectionFieldGroupTable).set({
+      deletedAt: sql3`now`
+    }).where(eq(inspectionFieldGroupTable.id, id));
+  };
+})(InspectionFieldGroupLogic ||= {});
+var logic_default26 = InspectionFieldGroupLogic;
+
+// src/routes/fleet/inspection/fieldGroup/model.ts
+var InspectionFieldGroupModel;
+((InspectionFieldGroupModel) => {
+  const createSchema = createInsertSchema(inspectionFieldGroupTable);
+  const updateSchema = createUpdateSchema(inspectionFieldGroupTable);
+  InspectionFieldGroupModel.create = OmitBaseSchema(createSchema);
+  InspectionFieldGroupModel.update = OmitBaseSchema(updateSchema);
+  InspectionFieldGroupModel.select = t.Composite([
+    t.Partial(t.Object({
+      name: t.String(),
+      code: t.String()
+    })),
+    PaginationSchema
+  ]);
+})(InspectionFieldGroupModel ||= {});
+var model_default25 = InspectionFieldGroupModel;
+
+// src/routes/fleet/inspection/fieldGroup/index.ts
+var fieldGroupRoutes = new Elysia({
+  prefix: "/field-group"
+}).use(better_auth_default).guard({
+  userKind: "ADMIN"
+}).get("/", async ({ query }) => logic_default26.select(query), {
+  query: model_default25.select,
+  userKind: undefined,
+  auth: true
+}).post("/", async ({ body }) => logic_default26.create(body), {
+  body: model_default25.create
+}).guard({
+  params: IdSchema
+}).put("/:id", async ({ body, params: { id } }) => logic_default26.update(id, body), {
+  body: model_default25.update
+}).delete("/:id", async ({ params: { id } }) => logic_default26.remove(id)).get("/:id/field", async ({ params: { id } }) => logic_default25.select(id));
+var fieldGroup_default = fieldGroupRoutes;
+
+// src/routes/fleet/inspection/index.ts
+var inspectionRoutes2 = new Elysia({
+  prefix: "/inspection"
+}).use(fieldGroup_default);
+var inspection_default2 = inspectionRoutes2;
+
+// src/routes/fleet/index.ts
+var fleetRoutes = new Elysia({ prefix: "/fleet" }).use(inspection_default2);
+var fleet_default = fleetRoutes;
+
 // src/routes/index.ts
 var router2 = new Elysia({
   prefix: "/api"
-}).use(imageRoutes).use(warehouse_default2).use(company_default2).use(permission_default2).use(user_default2).use(crm_default).use(techdoc_default);
+}).use(imageRoutes).use(warehouse_default2).use(company_default2).use(permission_default2).use(user_default2).use(crm_default).use(techdoc_default).use(fleet_default);
 var routes_default = router2;
 
 // src/index.ts