Merge 0f3dd097ec into 45213d0420

* openvino log message and preview directory checks

* restrict config vars for viewer users

* recording timestamp fix

when startTime is exactly on an hour boundary, findIndex returns the first matching chunk, which is the previous hour's chunk (where before == startTime), instead of the correct chunk (where after == startTime)

the bug shows up when using the share timestamp feature and sharing a specific timestamp on the exact hour mark. when accessing the shared link, the timeline would jump to the incorrect hour

* use helper for chunked time range

* Adjustments to contributing docs

* tweak

* Improve wording

* tweak

---------

Co-authored-by: Nicolas Mowen <nickmowen213@gmail.com>

.github/workflows/pr_template_check.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check PR description against template
-        uses: actions/github-script@v7
+        uses: actions/github-script@v9
         with:
           script: |
             const maintainers = ['blakeblackshear', 'NickM-27', 'hawkeye217', 'dependabot[bot]', 'weblate'];

.github/workflows/pull_request.yml

@@ -72,7 +72,7 @@ jobs:
         run: npm run e2e
         working-directory: ./web
       - name: Upload test artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         if: failure()
         with:
           name: playwright-report

.github/workflows/stale.yml

@@ -18,7 +18,7 @@ jobs:
           close-issue-message: ""
           days-before-stale: 30
           days-before-close: 3
-          exempt-draft-pr: true
+          exempt-draft-pr: false
           exempt-issue-labels: "planned,security"
           exempt-pr-labels: "planned,security,dependencies"
           operations-per-run: 120

CONTRIBUTING.md

@@ -10,11 +10,14 @@ If you've found a bug and want to fix it, go for it. Link to the relevant issue
 
 ### New features
 
-Every new feature adds scope that the maintainers must test, maintain, and support long-term. Before writing code for a new feature:
+A pull request is more than just code — it's a request for the maintainers to review, integrate, and support the change long-term. We're selective about what we take on, and prioritize changes that align with the project's direction and can be responsibly maintained in the long term.
+
+**Large or highly-requested features** raise the bar even higher. Popularity signals demand, but it doesn't pre-approve any particular implementation. The bigger the change, the higher the long-term cost, and the more important it is that we're aligned on scope and approach before any code is written. A large PR that lands without prior discussion is unlikely to be merged as-is, no matter how well it's implemented.
+
+Before writing code for a new feature:
 
 1. **Check for existing discussion.** Search [feature requests](https://github.com/blakeblackshear/frigate/issues) and [discussions](https://github.com/blakeblackshear/frigate/discussions) to see if it's been proposed or discussed. Feature requests tagged with "planned" are on our radar — we plan to get to them, but we don't maintain a public roadmap or timeline. Check in with us first if you have interest in contributing to one.
 2. **Start a discussion or feature request first.** This helps ensure your idea aligns with Frigate's direction before you invest time building it. Community interest in a feature request helps us gauge demand, though a great idea is a great idea even without a crowd behind it.
-3. **Be open to "no".** We try to be thoughtful about what we take on, and sometimes that means saying no to good code if the feature isn't the right fit for the project. These calls are sometimes subjective, and we won't always get them right. We're happy to discuss and reconsider.
 
 ## AI usage policy
 
@@ -39,6 +42,8 @@ We're not trying to gatekeep how you write code. Use whatever tools make you pro
 
 Some honest context: when we review a PR, we're not just evaluating whether the code works today. We're evaluating whether we can maintain it, debug it, and extend it long-term — often without the original author's involvement. Code that the author doesn't deeply understand is code that nobody understands, and that's a liability.
 
+One more thing worth saying directly: most maintainers already have access to the same AI tools you do. A PR that's entirely AI-generated — where the author can't explain the design, debug issues independently, or engage substantively in design discussions — doesn't offer something we couldn't produce ourselves. What makes a contribution genuinely valuable is the human judgment and domain understanding behind it, as well as the engagement during review that shapes it into something we can confidently take on long-term.
+
 ## Pull request guidelines
 
 ### Before submitting

Makefile

@@ -21,6 +21,13 @@ local: version
 		--tag frigate:latest \
 		--load
 
+localh10: version
+	docker buildx build --target=frigate --file docker/main/Dockerfile . \
+	    --build-arg HAILORT_VERSION=5.1.1 \
+		--build-arg HAILORT_GIT_REPO=mathieu-d/hailort \
+		--tag frigate:latest \
+		--load
+
 debug: version
 	docker buildx build --target=frigate --file docker/main/Dockerfile . \
 	    --build-arg DEBUG=true \

docker-compose.yml

@@ -12,6 +12,11 @@ services:
     build:
       context: .
       dockerfile: docker/main/Dockerfile
+      # Use args to specify hailort version and location
+      # args:
+      #   HAILORT_VERSION: "5.1.1"
+      #   HAILORT_GIT_REPO: "mathieu-d/hailort"
+
       # Use target devcontainer-trt for TensorRT dev
       target: devcontainer
       cache_from:
@@ -29,6 +34,7 @@ services:
     # devices:
       # - /dev/bus/usb:/dev/bus/usb # Uncomment for Google Coral USB
       # - /dev/dri:/dev/dri # for intel hwaccel, needs to be updated for your hardware
+
     volumes:
       - .:/workspace/frigate:cached
       - ./web/dist:/opt/frigate/web:cached

docker/hailo10h/user_installation.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Update package list and install hailo driver version 5.1.1 for Hailo-10H
+sudo apt update
+sudo apt install -y hailo-h10-all=5.1.1
+
+

docker/main/Dockerfile

@@ -157,6 +157,8 @@ FROM base AS wheels
 ARG DEBIAN_FRONTEND
 ARG TARGETARCH
 ARG DEBUG=false
+ARG HAILORT_VERSION=4.21.0
+ARG HAILORT_GIT_REPO=frigate-nvr/hailort
 
 # Use a separate container to build wheels to prevent build dependencies in final image
 RUN apt-get -qq update \

docker/main/install_hailort.sh

@@ -2,13 +2,11 @@
 
 set -euxo pipefail
 
-hailo_version="4.21.0"
-
 if [[ "${TARGETARCH}" == "amd64" ]]; then
     arch="x86_64"
 elif [[ "${TARGETARCH}" == "arm64" ]]; then
     arch="aarch64"
 fi
 
-wget -qO- "https://github.com/frigate-nvr/hailort/releases/download/v${hailo_version}/hailort-debian12-${TARGETARCH}.tar.gz" | tar -C / -xzf -
+wget -qO- "https://github.com/${HAILORT_GIT_REPO}/releases/download/v${HAILORT_VERSION}/hailort-debian12-${TARGETARCH}.tar.gz" | tar -C / -xzf -
-wget -P /wheels/ "https://github.com/frigate-nvr/hailort/releases/download/v${hailo_version}/hailort-${hailo_version}-cp311-cp311-linux_${arch}.whl"
+wget -P /wheels/ "https://github.com/${HAILORT_GIT_REPO}/releases/download/v${HAILORT_VERSION}/hailort-${HAILORT_VERSION}-cp311-cp311-linux_${arch}.whl"

frigate/api/app.py

@@ -146,8 +146,13 @@ def config(request: Request):
         for name, detector in config_obj.detectors.items()
     }
 
-    # remove the mqtt password
+    # remove environment_vars for non-admin users
+    if request.headers.get("remote-role") != "admin":
+        config.pop("environment_vars", None)
+
+    # remove mqtt credentials
     config["mqtt"].pop("password", None)
+    config["mqtt"].pop("user", None)
 
     # remove the proxy secret
     config["proxy"].pop("auth_secret", None)

frigate/detectors/plugins/hailo10h.py

@@ -0,0 +1,415 @@
+import logging
+import os
+import subprocess
+import threading
+import urllib.request
+from functools import partial
+from typing import Dict, List, Optional, Tuple
+
+import cv2
+import numpy as np
+from pydantic import ConfigDict, Field
+from typing_extensions import Literal
+
+from frigate.const import MODEL_CACHE_DIR
+from frigate.detectors.detection_api import DetectionApi
+from frigate.detectors.detector_config import (
+    BaseDetectorConfig,
+)
+from frigate.object_detection.util import RequestStore, ResponseStore
+
+logger = logging.getLogger(__name__)
+
+
+# ----------------- Utility Functions ----------------- #
+
+
+def preprocess_tensor(image: np.ndarray, model_w: int, model_h: int) -> np.ndarray:
+    """
+    Resize an image with unchanged aspect ratio using padding.
+    Assumes input image shape is (H, W, 3).
+    """
+    if image.ndim == 4 and image.shape[0] == 1:
+        image = image[0]
+
+    h, w = image.shape[:2]
+    scale = min(model_w / w, model_h / h)
+    new_w, new_h = int(w * scale), int(h * scale)
+    resized_image = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_CUBIC)
+    padded_image = np.full((model_h, model_w, 3), 114, dtype=image.dtype)
+    x_offset = (model_w - new_w) // 2
+    y_offset = (model_h - new_h) // 2
+    padded_image[y_offset : y_offset + new_h, x_offset : x_offset + new_w] = (
+        resized_image
+    )
+    return padded_image
+
+
+# ----------------- Global Constants ----------------- #
+DETECTOR_KEY = "hailo10h"
+ARCH = None
+H10H_DEFAULT_MODEL = "yolov6n.hef"
+H10H_DEFAULT_URL = "https://hailo-model-zoo.s3.eu-west-2.amazonaws.com/ModelZoo/Compiled/v5.2.0/hailo10h/yolov6n.hef"
+
+
+def detect_hailo_arch():
+    try:
+        result = subprocess.run(
+            ["hailortcli", "fw-control", "identify"], capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            logger.error(f"Inference error: {result.stderr}")
+            return None
+        for line in result.stdout.split("\n"):
+            if "Device Architecture" in line:
+                if "HAILO10H" in line:
+                    return "hailo10h"
+        logger.error("Inference error: Could not determine Hailo architecture.")
+        return None
+    except Exception as e:
+        logger.error(f"Inference error: {e}")
+        return None
+
+
+# ----------------- HailoAsyncInference Class ----------------- #
+class HailoAsyncInference:
+    def __init__(
+        self,
+        hef_path: str,
+        input_store: RequestStore,
+        output_store: ResponseStore,
+        batch_size: int = 1,
+        input_type: Optional[str] = None,
+        output_type: Optional[Dict[str, str]] = None,
+        send_original_frame: bool = False,
+    ) -> None:
+        # when importing hailo it activates the driver
+        # which leaves processes running even though it may not be used.
+        try:
+            from hailo_platform import (
+                HEF,
+                FormatType,
+                HailoSchedulingAlgorithm,
+                VDevice,
+            )
+        except ModuleNotFoundError:
+            pass
+
+        self.input_store = input_store
+        self.output_store = output_store
+
+        params = VDevice.create_params()
+        params.scheduling_algorithm = HailoSchedulingAlgorithm.ROUND_ROBIN
+
+        self.hef = HEF(hef_path)
+        self.target = VDevice(params)
+        self.infer_model = self.target.create_infer_model(hef_path)
+        self.infer_model.set_batch_size(batch_size)
+
+        if input_type is not None:
+            self.infer_model.input().set_format_type(getattr(FormatType, input_type))
+
+        if output_type is not None:
+            for output_name, output_type in output_type.items():
+                self.infer_model.output(output_name).set_format_type(
+                    getattr(FormatType, output_type)
+                )
+
+        self.output_type = output_type
+        self.send_original_frame = send_original_frame
+
+    def callback(
+        self,
+        completion_info,
+        bindings_list: List,
+        input_batch: List,
+        request_ids: List[int],
+    ):
+        if completion_info.exception:
+            logger.error(f"Inference error: {completion_info.exception}")
+        else:
+            for i, bindings in enumerate(bindings_list):
+                if len(bindings._output_names) == 1:
+                    result = bindings.output().get_buffer()
+                else:
+                    result = {
+                        name: np.expand_dims(bindings.output(name).get_buffer(), axis=0)
+                        for name in bindings._output_names
+                    }
+                self.output_store.put(request_ids[i], (input_batch[i], result))
+
+    def _create_bindings(self, configured_infer_model) -> object:
+        if self.output_type is None:
+            output_buffers = {
+                output_info.name: np.empty(
+                    self.infer_model.output(output_info.name).shape,
+                    dtype=getattr(
+                        np, str(output_info.format.type).split(".")[1].lower()
+                    ),
+                )
+                for output_info in self.hef.get_output_vstream_infos()
+            }
+        else:
+            output_buffers = {
+                name: np.empty(
+                    self.infer_model.output(name).shape,
+                    dtype=getattr(np, self.output_type[name].lower()),
+                )
+                for name in self.output_type
+            }
+        return configured_infer_model.create_bindings(output_buffers=output_buffers)
+
+    def get_input_shape(self) -> Tuple[int, ...]:
+        return self.hef.get_input_vstream_infos()[0].shape
+
+    def run(self) -> None:
+        job = None
+        with self.infer_model.configure() as configured_infer_model:
+            while True:
+                batch_data = self.input_store.get()
+
+                if batch_data is None:
+                    break
+
+                request_id, frame_data = batch_data
+                preprocessed_batch = [frame_data]
+                request_ids = [request_id]
+                input_batch = preprocessed_batch  # non-send_original_frame mode
+
+                bindings_list = []
+                for frame in preprocessed_batch:
+                    bindings = self._create_bindings(configured_infer_model)
+                    bindings.input().set_buffer(np.array(frame))
+                    bindings_list.append(bindings)
+                configured_infer_model.wait_for_async_ready(timeout_ms=10000)
+                job = configured_infer_model.run_async(
+                    bindings_list,
+                    partial(
+                        self.callback,
+                        input_batch=input_batch,
+                        request_ids=request_ids,
+                        bindings_list=bindings_list,
+                    ),
+                )
+
+            if job is not None:
+                job.wait(100)
+
+
+# ----------------- HailoDetector Class ----------------- #
+class HailoDetector(DetectionApi):
+    type_key = DETECTOR_KEY
+
+    def __init__(self, detector_config: "HailoDetectorConfig"):
+        global ARCH
+        ARCH = detect_hailo_arch()
+        self.cache_dir = MODEL_CACHE_DIR
+        self.device_type = detector_config.device
+        self.model_height = (
+            detector_config.model.height
+            if hasattr(detector_config.model, "height")
+            else None
+        )
+        self.model_width = (
+            detector_config.model.width
+            if hasattr(detector_config.model, "width")
+            else None
+        )
+        self.model_type = (
+            detector_config.model.model_type
+            if hasattr(detector_config.model, "model_type")
+            else None
+        )
+        self.tensor_format = (
+            detector_config.model.input_tensor
+            if hasattr(detector_config.model, "input_tensor")
+            else None
+        )
+        self.pixel_format = (
+            detector_config.model.input_pixel_format
+            if hasattr(detector_config.model, "input_pixel_format")
+            else None
+        )
+        self.input_dtype = (
+            detector_config.model.input_dtype
+            if hasattr(detector_config.model, "input_dtype")
+            else None
+        )
+        self.output_type = "FLOAT32"
+        self.set_path_and_url(detector_config.model.path)
+        self.working_model_path = self.check_and_prepare()
+
+        self.batch_size = 1
+        self.input_store = RequestStore()
+        self.response_store = ResponseStore()
+
+        try:
+            logger.debug(f"[INIT] Loading HEF model from {self.working_model_path}")
+            self.inference_engine = HailoAsyncInference(
+                self.working_model_path,
+                self.input_store,
+                self.response_store,
+                self.batch_size,
+            )
+            self.input_shape = self.inference_engine.get_input_shape()
+            logger.debug(f"[INIT] Model input shape: {self.input_shape}")
+            self.inference_thread = threading.Thread(
+                target=self.inference_engine.run, daemon=True
+            )
+            self.inference_thread.start()
+        except Exception as e:
+            logger.error(f"[INIT] Failed to initialize HailoAsyncInference: {e}")
+            raise
+
+    def set_path_and_url(self, path: str = None):
+        if not path:
+            self.model_path = None
+            self.url = None
+            return
+        if self.is_url(path):
+            self.url = path
+            self.model_path = None
+        else:
+            self.model_path = path
+            self.url = None
+
+    def is_url(self, url: str) -> bool:
+        return (
+            url.startswith("http://")
+            or url.startswith("https://")
+            or url.startswith("www.")
+        )
+
+    @staticmethod
+    def extract_model_name(path: str = None, url: str = None) -> str:
+        if path and path.endswith(".hef"):
+            return os.path.basename(path)
+        elif url and url.endswith(".hef"):
+            return os.path.basename(url)
+        else:
+            return H10H_DEFAULT_MODEL
+
+    @staticmethod
+    def download_model(url: str, destination: str):
+        if not url.endswith(".hef"):
+            raise ValueError("Invalid model URL. Only .hef files are supported.")
+        try:
+            urllib.request.urlretrieve(url, destination)
+            logger.debug(f"Downloaded model to {destination}")
+        except Exception as e:
+            raise RuntimeError(f"Failed to download model from {url}: {str(e)}")
+
+    def check_and_prepare(self) -> str:
+        if not os.path.exists(self.cache_dir):
+            os.makedirs(self.cache_dir)
+        model_name = self.extract_model_name(self.model_path, self.url)
+        cached_model_path = os.path.join(self.cache_dir, model_name)
+        if not self.model_path and not self.url:
+            if os.path.exists(cached_model_path):
+                logger.debug(f"Model found in cache: {cached_model_path}")
+                return cached_model_path
+            else:
+                logger.debug(f"Downloading default model: {model_name}")
+                self.download_model(H10H_DEFAULT_URL, cached_model_path)
+
+        elif self.url:
+            logger.debug(f"Downloading model from URL: {self.url}")
+            self.download_model(self.url, cached_model_path)
+        elif self.model_path:
+            if os.path.exists(self.model_path):
+                logger.debug(f"Using existing model at: {self.model_path}")
+                return self.model_path
+            else:
+                raise FileNotFoundError(f"Model file not found at: {self.model_path}")
+        return cached_model_path
+
+    def detect_raw(self, tensor_input):
+        tensor_input = self.preprocess(tensor_input)
+
+        if isinstance(tensor_input, np.ndarray) and len(tensor_input.shape) == 3:
+            tensor_input = np.expand_dims(tensor_input, axis=0)
+
+        request_id = self.input_store.put(tensor_input)
+
+        try:
+            _, infer_results = self.response_store.get(request_id, timeout=1.0)
+        except TimeoutError:
+            logger.error(
+                f"Timeout waiting for inference results for request {request_id}"
+            )
+
+            if not self.inference_thread.is_alive():
+                raise RuntimeError(
+                    "HailoRT inference thread has stopped, restart required."
+                )
+
+            return np.zeros((20, 6), dtype=np.float32)
+
+        if isinstance(infer_results, list) and len(infer_results) == 1:
+            infer_results = infer_results[0]
+
+        threshold = 0.4
+        all_detections = []
+        for class_id, detection_set in enumerate(infer_results):
+            if not isinstance(detection_set, np.ndarray) or detection_set.size == 0:
+                continue
+            for det in detection_set:
+                if det.shape[0] < 5:
+                    continue
+                score = float(det[4])
+                if score < threshold:
+                    continue
+                all_detections.append([class_id, score, det[0], det[1], det[2], det[3]])
+
+        if len(all_detections) == 0:
+            detections_array = np.zeros((20, 6), dtype=np.float32)
+        else:
+            detections_array = np.array(all_detections, dtype=np.float32)
+            if detections_array.shape[0] > 20:
+                detections_array = detections_array[:20, :]
+            elif detections_array.shape[0] < 20:
+                pad = np.zeros((20 - detections_array.shape[0], 6), dtype=np.float32)
+                detections_array = np.vstack((detections_array, pad))
+
+        return detections_array
+
+    def preprocess(self, image):
+        if isinstance(image, np.ndarray):
+            processed = preprocess_tensor(
+                image, self.input_shape[1], self.input_shape[0]
+            )
+            return np.expand_dims(processed, axis=0)
+        else:
+            raise ValueError("Unsupported image format for preprocessing")
+
+    def close(self):
+        """Properly shuts down the inference engine and releases the VDevice."""
+        logger.debug("[CLOSE] Closing HailoDetector")
+        try:
+            if hasattr(self, "inference_engine"):
+                if hasattr(self.inference_engine, "target"):
+                    self.inference_engine.target.release()
+                logger.debug("Hailo VDevice released successfully")
+        except Exception as e:
+            logger.error(f"Failed to close Hailo device: {e}")
+            raise
+
+    def __del__(self):
+        """Destructor to ensure cleanup when the object is deleted."""
+        self.close()
+
+
+# ----------------- HailoDetectorConfig Class ----------------- #
+class HailoDetectorConfig(BaseDetectorConfig):
+    """Hailo10H detector using HEF models and the HailoRT SDK for inference on Hailo hardware."""
+
+    model_config = ConfigDict(
+        title="Hailo-10H",
+    )
+
+    type: Literal[DETECTOR_KEY]
+    device: str = Field(
+        default="PCIe",
+        title="Device Type",
+        description="The device to use for Hailo inference (e.g. 'PCIe', 'M.2').",
+    )

frigate/detectors/plugins/openvino.py

@@ -52,6 +52,12 @@ class OvDetector(DetectionApi):
         self.h = detector_config.model.height
         self.w = detector_config.model.width
 
+        logger.info(
+            "Loading OpenVINO model %s on device %s",
+            detector_config.model.path,
+            detector_config.device,
+        )
+
         self.runner = OpenVINOModelRunner(
             model_path=detector_config.model.path,
             device=detector_config.device,

frigate/output/birdseye.py

@@ -8,7 +8,6 @@ import os
 import queue
 import subprocess as sp
 import threading
-import time
 import traceback
 from multiprocessing.synchronize import Event as MpEvent
 from typing import Any, Optional
@@ -882,7 +881,7 @@ class Birdseye:
                 coordinates = self.birdseye_manager.get_camera_coordinates()
                 self.requestor.send_data(UPDATE_BIRDSEYE_LAYOUT, coordinates)
         if self._idle_interval:
-            now = time.monotonic()
+            now = datetime.datetime.now().timestamp()
             is_idle = len(self.birdseye_manager.camera_layout) == 0
             if (
                 is_idle

frigate/output/output.py

@@ -349,6 +349,13 @@ def move_preview_frames(loc: str) -> None:
             if not os.path.exists(preview_holdover):
                 return
 
+            if not os.access(preview_holdover, os.R_OK | os.W_OK):
+                logger.error(
+                    "Insufficient permissions on preview restart cache at %s",
+                    preview_holdover,
+                )
+                return
+
             shutil.move(preview_holdover, preview_cache)
     except shutil.Error:
         logger.error("Failed to restore preview cache.")

frigate/output/preview.py

@@ -361,14 +361,17 @@ class PreviewRecorder:
             small_frame,
             cv2.COLOR_YUV2BGR_I420,
         )
-        cv2.imwrite(
+        cache_path = get_cache_image_name(self.camera_name, frame_time)
-            get_cache_image_name(self.camera_name, frame_time),
+
+        if not cv2.imwrite(
+            cache_path,
             small_frame,
             [
                 int(cv2.IMWRITE_WEBP_QUALITY),
                 PREVIEW_QUALITY_WEBP[self.config.record.preview.quality],
             ],
-        )
+        ):
+            logger.error("Failed to write preview frame to %s", cache_path)
 
     def write_data(
         self,

frigate/record/export.py

@@ -28,7 +28,7 @@ from frigate.ffmpeg_presets import (
     EncodeTypeEnum,
     parse_preset_hardware_acceleration_encode,
 )
-from frigate.models import Export, Previews, Recordings
+from frigate.models import Export, Previews, Recordings, ReviewSegment
 from frigate.util.time import is_current_hour
 
 logger = logging.getLogger(__name__)
@@ -347,6 +347,122 @@ class RecordingExporter(threading.Thread):
         # return in iso format
         return datetime.datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
 
+    def _chapter_metadata_path(self) -> str:
+        return os.path.join(CACHE_DIR, f"export_chapters_{self.export_id}.txt")
+
+    def _build_chapter_metadata_file(self, recordings: list) -> Optional[str]:
+        """Write an FFmpeg metadata file with chapters for review items in range.
+
+        Chapter offsets are computed in *output time*: the VOD endpoint
+        concatenates recording clips back-to-back, so wall-clock gaps
+        between recordings collapse in the produced video. We walk the
+        same recording rows that feed the playlist and convert each
+        review item's wall-clock boundaries into output-time offsets.
+        Returns ``None`` when there are no recordings, no review items,
+        or any chapter would have zero output duration.
+        """
+        if not recordings:
+            return None
+
+        windows: list[tuple[float, float, float]] = []
+        output_offset = 0.0
+        for rec in recordings:
+            clipped_start = max(float(rec.start_time), float(self.start_time))
+            clipped_end = min(float(rec.end_time), float(self.end_time))
+            if clipped_end <= clipped_start:
+                continue
+            windows.append((clipped_start, clipped_end, output_offset))
+            output_offset += clipped_end - clipped_start
+
+        if not windows:
+            return None
+
+        try:
+            review_rows = list(
+                ReviewSegment.select(
+                    ReviewSegment.start_time,
+                    ReviewSegment.end_time,
+                    ReviewSegment.severity,
+                    ReviewSegment.data,
+                )
+                .where(
+                    ReviewSegment.start_time.between(self.start_time, self.end_time)
+                    | ReviewSegment.end_time.between(self.start_time, self.end_time)
+                    | (
+                        (self.start_time > ReviewSegment.start_time)
+                        & (self.end_time < ReviewSegment.end_time)
+                    )
+                )
+                .where(ReviewSegment.camera == self.camera)
+                .order_by(ReviewSegment.start_time.asc())
+                .iterator()
+            )
+        except Exception:
+            logger.exception(
+                "Failed to query review segments for export %s", self.export_id
+            )
+            return None
+
+        if not review_rows:
+            return None
+
+        total_output = windows[-1][2] + (windows[-1][1] - windows[-1][0])
+
+        def wall_to_output(t: float) -> float:
+            t = max(float(self.start_time), min(float(self.end_time), t))
+            for w_start, w_end, w_offset in windows:
+                if t < w_start:
+                    return w_offset
+                if t <= w_end:
+                    return w_offset + (t - w_start)
+            return total_output
+
+        chapter_blocks: list[str] = []
+        for review in review_rows:
+            start_out = wall_to_output(float(review.start_time))
+            end_out = wall_to_output(float(review.end_time))
+
+            # Drop chapters that fall entirely in a recording gap, or are
+            # too short to be navigable in a player.
+            if end_out - start_out < 1.0:
+                continue
+
+            data = review.data or {}
+            labels: list[str] = []
+            for obj in data.get("objects") or []:
+                label = str(obj).split("-")[0]
+                if label and label not in labels:
+                    labels.append(label)
+
+            title = str(review.severity).capitalize()
+            if labels:
+                title = f"{title}: {', '.join(labels)}"
+
+            chapter_blocks.append(
+                "[CHAPTER]\n"
+                "TIMEBASE=1/1000\n"
+                f"START={int(start_out * 1000)}\n"
+                f"END={int(end_out * 1000)}\n"
+                f"title={title}"
+            )
+
+        if not chapter_blocks:
+            return None
+
+        meta_path = self._chapter_metadata_path()
+        try:
+            with open(meta_path, "w", encoding="utf-8") as f:
+                f.write(";FFMETADATA1\n")
+                f.write("\n".join(chapter_blocks))
+                f.write("\n")
+        except OSError:
+            logger.exception(
+                "Failed to write chapter metadata file for export %s", self.export_id
+            )
+            return None
+
+        return meta_path
+
     def save_thumbnail(self, id: str) -> str:
         thumb_path = os.path.join(CLIPS_DIR, f"export/{id}.webp")
 
@@ -451,6 +567,24 @@ class RecordingExporter(threading.Thread):
         if type(internal_port) is str:
             internal_port = int(internal_port.split(":")[-1])
 
+        recordings = list(
+            Recordings.select(
+                Recordings.start_time,
+                Recordings.end_time,
+            )
+            .where(
+                Recordings.start_time.between(self.start_time, self.end_time)
+                | Recordings.end_time.between(self.start_time, self.end_time)
+                | (
+                    (self.start_time > Recordings.start_time)
+                    & (self.end_time < Recordings.end_time)
+                )
+            )
+            .where(Recordings.camera == self.camera)
+            .order_by(Recordings.start_time.asc())
+            .iterator()
+        )
+
         playlist_lines: list[str] = []
         if (self.end_time - self.start_time) <= MAX_PLAYLIST_SECONDS:
             playlist_url = f"http://127.0.0.1:{internal_port}/vod/{self.camera}/start/{self.start_time}/end/{self.end_time}/index.m3u8"
@@ -458,32 +592,13 @@ class RecordingExporter(threading.Thread):
                 f"-y -protocol_whitelist pipe,file,http,tcp -i {playlist_url}"
             )
         else:
-            # get full set of recordings
+            # Chunk the recording rows into pages so each playlist line
-            export_recordings = (
+            # references a bounded sub-range rather than the full export.
-                Recordings.select(
-                    Recordings.start_time,
-                    Recordings.end_time,
-                )
-                .where(
-                    Recordings.start_time.between(self.start_time, self.end_time)
-                    | Recordings.end_time.between(self.start_time, self.end_time)
-                    | (
-                        (self.start_time > Recordings.start_time)
-                        & (self.end_time < Recordings.end_time)
-                    )
-                )
-                .where(Recordings.camera == self.camera)
-                .order_by(Recordings.start_time.asc())
-            )
-
-            # Use pagination to process records in chunks
             page_size = 1000
-            num_pages = (export_recordings.count() + page_size - 1) // page_size
+            for i in range(0, len(recordings), page_size):
-
+                chunk = recordings[i : i + page_size]
-            for page in range(1, num_pages + 1):
-                playlist = export_recordings.paginate(page, page_size)
                 playlist_lines.append(
-                    f"file 'http://127.0.0.1:{internal_port}/vod/{self.camera}/start/{float(playlist[0].start_time)}/end/{float(playlist[-1].end_time)}/index.m3u8'"
+                    f"file 'http://127.0.0.1:{internal_port}/vod/{self.camera}/start/{float(chunk[0].start_time)}/end/{float(chunk[-1].end_time)}/index.m3u8'"
                 )
 
             ffmpeg_input = "-y -protocol_whitelist pipe,file,http,tcp -f concat -safe 0 -i /dev/stdin"
@@ -504,8 +619,12 @@ class RecordingExporter(threading.Thread):
                 )
             ).split(" ")
         else:
+            chapters_path = self._build_chapter_metadata_file(recordings)
+            chapter_args = (
+                f" -i {chapters_path} -map 0 -map_metadata 1" if chapters_path else ""
+            )
             ffmpeg_cmd = (
-                f"{self.config.ffmpeg.ffmpeg_path} -hide_banner {ffmpeg_input} -c copy -movflags +faststart"
+                f"{self.config.ffmpeg.ffmpeg_path} -hide_banner {ffmpeg_input}{chapter_args} -c copy -movflags +faststart"
             ).split(" ")
 
         # add metadata
@@ -691,6 +810,8 @@ class RecordingExporter(threading.Thread):
                 ffmpeg_cmd, playlist_lines, step="encoding_retry"
             )
 
+        Path(self._chapter_metadata_path()).unlink(missing_ok=True)
+
         if returncode != 0:
             logger.error(
                 f"Failed to export {self.playback_source.value} for command {' '.join(ffmpeg_cmd)}"

frigate/stats/util.py

@@ -123,6 +123,15 @@ def get_detector_temperature(
             if index < len(hailo_device_names):
                 device_name = hailo_device_names[index]
                 return hailo_temps[device_name]
+    elif detector_type == "hailo10h":
+        # Get temperatures for Hailo devices
+        hailo_temps = get_hailo_temps()
+        if hailo_temps:
+            hailo_device_names = sorted(hailo_temps.keys())
+            index = detector_index_by_type.get("hailo10h", 0)
+            if index < len(hailo_device_names):
+                device_name = hailo_device_names[index]
+                return hailo_temps[device_name]
     elif detector_type == "rknn":
         # Rockchip temperatures are handled by the GPU / NPU stats
         # as there are not detector specific temperatures

web/public/locales/bg/config/global.json

@@ -1 +1,8 @@
-{}
+{
+    "auth": {
+        "label": "Автентикация",
+        "session_length": {
+            "label": "Продължителност на сесията"
+        }
+    }
+}

web/public/locales/ca/common.json

@@ -109,7 +109,8 @@
     "classification": "Classificació",
     "chat": "Xat",
     "actions": "Accions",
-    "profiles": "Perfils"
+    "profiles": "Perfils",
+    "features": "Característiques"
   },
   "pagination": {
     "previous": {

web/public/locales/ca/components/dialog.json

@@ -60,15 +60,76 @@
         "noVaildTimeSelected": "No s'ha seleccionat un rang de temps vàlid",
         "failed": "No s'ha pogut inciar l'exportació: {{error}}"
       },
-      "view": "Vista"
+      "view": "Vista",
+      "queued": "Exporta a la cua. Mostra el progrés a la pàgina d'exportacions.",
+      "batchSuccess_one": "S'ha iniciat l'exportació 1. Obrint el cas ara.",
+      "batchSuccess_many": "S'han iniciat {{count}} exportacions. Obrint el cas ara.",
+      "batchSuccess_other": "S'han iniciat {{count}} exportacions. Obrint el cas ara.",
+      "batchPartial": "S'han iniciat {{successful}} de {{total}} exportacions. Càmeres fallides: {{failedCameras}}",
+      "batchFailed": "No s'han pogut iniciar {{total}} exportacions. Càmeres fallides: {{failedCameras}}",
+      "batchQueuedSuccess_one": "Exporta a la cua 1. Obrint el cas ara.",
+      "batchQueuedSuccess_many": "{{count}} exportacions a la cua. Obrint el cas ara.",
+      "batchQueuedSuccess_other": "{{count}} exportacions a la cua. Obrint el cas ara.",
+      "batchQueuedPartial": "{{successful}} de {{total}} exportacions a la cua. Càmeres fallides: {{failedCameras}}",
+      "batchQueueFailed": "No s'han pogut posar a la cua {{total}} exportacions. Càmeres fallides: {{failedCameras}}"
     },
     "fromTimeline": {
       "saveExport": "Guardar exportació",
-      "previewExport": "Previsualitzar exportació"
+      "previewExport": "Previsualitzar exportació",
+      "queueingExport": "S'està fent la cua de l'exportació...",
+      "useThisRange": "Utilitza aquest interval"
     },
     "case": {
       "label": "Cas",
-      "placeholder": "Selecciona un cas"
+      "placeholder": "Selecciona un cas",
+      "newCaseOption": "Crea un cas no",
+      "newCaseNamePlaceholder": "Nom de cas nou",
+      "newCaseDescriptionPlaceholder": "Descripció del cas",
+      "nonAdminHelp": "Es crearà un nou cas per a aquestes exportacions."
+    },
+    "queueing": "S'està fent la cua de l'exportació...",
+    "tabs": {
+      "export": "Càmera única",
+      "multiCamera": "Multicàmera"
+    },
+    "multiCamera": {
+      "timeRange": "Interval de temps",
+      "selectFromTimeline": "Selecciona des de la línia de temps",
+      "cameraSelection": "Càmeres",
+      "cameraSelectionHelp": "Les càmeres amb objectes rastrejats en aquest interval de temps estan preseleccionades",
+      "checkingActivity": "Comprovant l'activitat de la càmera...",
+      "noCameras": "No hi ha càmeres disponibles",
+      "detectionCount_one": "1 objecte rastrejat",
+      "detectionCount_many": "{{count}} objectes rastrejats",
+      "detectionCount_other": "{{count}} objectes rastrejats",
+      "nameLabel": "Nom de l'exportació",
+      "namePlaceholder": "Nom base opcional per a aquestes exportacions",
+      "queueingButton": "S'estan posant a la cua les exportacions...",
+      "exportButton_one": "Exporta 1 càmera",
+      "exportButton_many": "Exporta {{count}} càmeres",
+      "exportButton_other": "Exporta {{count}} càmeres"
+    },
+    "multi": {
+      "title_one": "Exporta {{count}} ressenyes",
+      "title_many": "Exporta {{count}} ressenyes",
+      "title_other": "Exporta {{count}} ressenyes",
+      "description": "Exporta cada revisió seleccionada. Totes les exportacions s'agruparan en un sol cas.",
+      "descriptionNoCase": "Exporta cada revisió seleccionada.",
+      "caseNamePlaceholder": "Exporta la revisió - {{date}}",
+      "exportButton_one": "Exporta {{count}} ressenyes",
+      "exportButton_many": "Exporta {{count}} ressenyes",
+      "exportButton_other": "Exporta {{count}} ressenyes",
+      "exportingButton": "S'està exportant...",
+      "toast": {
+        "started_one": "S'ha iniciat l'exportació 1. Obrint el cas ara.",
+        "started_many": "S'han iniciat {{count}} exportacions. Obrint el cas ara.",
+        "started_other": "S'han iniciat {{count}} exportacions. Obrint el cas ara.",
+        "startedNoCase_one": "S'ha iniciat l'exportació 1.",
+        "startedNoCase_many": "S'han iniciat {{count}} exportacions.",
+        "startedNoCase_other": "S'han iniciat {{count}} exportacions.",
+        "partial": "S'han iniciat {{successful}} de {{total}} exportacions. Ha fallat: {{failedItems}}",
+        "failed": "No s'han pogut iniciar {{total}} exportacions. Ha fallat: {{failedItems}}"
+      }
     }
   },
   "streaming": {
@@ -116,6 +177,14 @@
         "success": "Els enregistraments de vídeo associats als elements de revisió seleccionats s’han suprimit correctament.",
         "error": "No s'ha pogut suprimir: {{error}}"
       }
+    },
+    "shareTimestamp": {
+      "label": "Comparteix la marca horària",
+      "title": "Comparteix la marca horària",
+      "description": "Comparteix un URL amb marca horària de la posició actual del jugador o tria una marca horària personalitzada. Tingueu en compte que aquest no és un URL de compartició pública i només és accessible per als usuaris amb accés a Frigate i aquesta càmera.",
+      "custom": "Marca horària personalitzada",
+      "button": "Comparteix l'URL de la marca horària",
+      "shareTitle": "Marca de temps de revisió de Frigate: {{camera}}"
     }
   },
   "imagePicker": {

web/public/locales/ca/components/player.json

@@ -32,7 +32,8 @@
   "noPreviewFoundFor": "No s'ha trobat cap previsualització per a {{cameraName}}",
   "submitFrigatePlus": {
     "title": "Enviar aquesta imatge a Frigate+?",
-    "submit": "Enviar"
+    "submit": "Enviar",
+    "previewError": "No s'ha pogut carregar la vista prèvia de la instantània. És possible que l'enregistrament no estigui disponible en aquest moment."
   },
   "livePlayerRequiredIOSVersion": "Es requereix iOS 17.1 o superior per a aquest tipus de reproducció en directe.",
   "streamOffline": {

web/public/locales/ca/config/global.json

@@ -1951,7 +1951,7 @@
         },
         "roles": {
             "label": "Rols",
-            "description": "Funcions genAI (eines, visió, incrustacions); un proveïdor per rol."
+            "description": "Rols de GenAI (xat, descripcions, incrustacions); un proveïdor per rol."
         },
         "provider_options": {
             "label": "Opcions del proveïdor",

web/public/locales/ca/views/events.json

@@ -27,7 +27,9 @@
   },
   "documentTitle": "Revisió - Frigate",
   "recordings": {
-    "documentTitle": "Enregistraments - Frigate"
+    "documentTitle": "Enregistraments - Frigate",
+    "invalidSharedLink": "No s'ha pogut obrir l'enllaç d'enregistrament amb marques de temps a causa d'un error d'anàlisi.",
+    "invalidSharedCamera": "No s'ha pogut obrir l'enllaç d'enregistrament amb marques de temps a causa d'una càmera desconeguda o no autoritzada."
   },
   "calendarFilter": {
     "last24Hours": "Últimes 24 hores"

web/public/locales/ca/views/explore.json

@@ -248,7 +248,7 @@
   "dialog": {
     "confirmDelete": {
       "title": "Confirmar la supressió",
-      "desc": "Eliminant aquest objecte seguit borrarà l'snapshot, qualsevol embedding gravat, i qualsevol detall de seguiment. Les imatges gravades d'aquest objecte seguit en l'historial <em>NO</em> seràn eliminades.<br /><br />Estas segur que vols continuar?"
+      "desc": "Suprimir aquest objecte rastrejat elimina la instantània, qualsevol incrustació desada, i qualsevol entrada de detalls de seguiment associada. Les imatges gravades d'aquest objecte seguit en l'historial <em>NO</em> seràn eliminades.<br /><br />Estas segur que vols continuar?"
     },
     "toast": {
       "error": "S'ha produït un error en suprimir aquest objecte rastrejat: {{errorMessage}}"
@@ -289,7 +289,10 @@
         "zones": "Zones",
         "ratio": "Ràtio",
         "area": "Àrea",
-        "score": "Puntuació"
+        "score": "Puntuació",
+        "computedScore": "Puntuació calculada",
+        "topScore": "Puntuació superior",
+        "toggleAdvancedScores": "Commuta les puntuacions avançades"
       }
     },
     "annotationSettings": {

web/public/locales/ca/views/exports.json

@@ -14,7 +14,9 @@
   "toast": {
     "error": {
       "renameExportFailed": "Error al canviar el nom de l’exportació: {{errorMessage}}",
-      "assignCaseFailed": "No s'ha pogut actualitzar l'assignació de cas:{{errorMessage}}"
+      "assignCaseFailed": "No s'ha pogut actualitzar l'assignació de cas:{{errorMessage}}",
+      "caseSaveFailed": "No s'ha pogut desar el cas: {{errorMessage}}",
+      "caseDeleteFailed": "No s'ha pogut suprimir el cas: {{errorMessage}}"
     }
   },
   "tooltip": {
@@ -22,7 +24,8 @@
     "downloadVideo": "Baixa el vídeo",
     "editName": "Edita el nom",
     "deleteExport": "Suprimeix l'exportació",
-    "assignToCase": "Afegeix al cas"
+    "assignToCase": "Afegeix al cas",
+    "removeFromCase": "Elimina del cas"
   },
   "headings": {
     "cases": "Casos",
@@ -35,5 +38,91 @@
     "newCaseOption": "Crea un cas nou",
     "nameLabel": "Nom del cas",
     "descriptionLabel": "Descripció"
+  },
+  "toolbar": {
+    "newCase": "Cas nou",
+    "addExport": "Afegeix una exportació",
+    "editCase": "Edita el cas",
+    "deleteCase": "Suprimeix el cas"
+  },
+  "deleteCase": {
+    "label": "Suprimeix el cas",
+    "desc": "Esteu segur que voleu suprimir {{caseName}}?",
+    "descKeepExports": "Les exportacions continuaran estant disponibles com a exportacions sense categoria.",
+    "descDeleteExports": "Totes les exportacions en aquest cas s'eliminaran permanentment.",
+    "deleteExports": "Elimina també les exportacions"
+  },
+  "caseCard": {
+    "emptyCase": "Encara no hi ha exportacions"
+  },
+  "jobCard": {
+    "defaultName": "Exportació de {{camera}}",
+    "queued": "En cua",
+    "running": "En execució",
+    "preparing": "Preparant",
+    "copying": "Copiant",
+    "encoding": "Codificant",
+    "encodingRetry": "Codificant (reintent)",
+    "finalizing": "Finalitzant"
+  },
+  "caseView": {
+    "noDescription": "Sense descripció",
+    "createdAt": "{{value}} creat",
+    "exportCount_one": "1 exportació",
+    "exportCount_other": "{{count}} exportacions",
+    "cameraCount_one": "1 càmera",
+    "cameraCount_other": "{{count}} càmeres",
+    "showMore": "Mostra'n més",
+    "showLess": "Mostra menys",
+    "emptyTitle": "Aquest cas és buit",
+    "emptyDescription": "Afegeix les exportacions no categoritzades existents per mantenir el cas organitzat.",
+    "emptyDescriptionNoExports": "Encara no hi ha exportacions sense categoria per afegir."
+  },
+  "caseEditor": {
+    "createTitle": "Crea un cas",
+    "editTitle": "Edita el cas",
+    "namePlaceholder": "Nom del cas",
+    "descriptionPlaceholder": "Afegeix notes o context per a aquest cas"
+  },
+  "addExportDialog": {
+    "title": "Afegeix l'exportació a {{caseName}}",
+    "searchPlaceholder": "Cerca exportacions sense categoria",
+    "empty": "No hi ha exportacions sense categoria que coincideixin amb aquesta cerca.",
+    "addButton_one": "Afegeix 1 exportació",
+    "addButton_other": "Afegeix {{count}} exportacions",
+    "adding": "S'està afegint..."
+  },
+  "selected_one": "{{count}} seleccionats",
+  "selected_other": "{{count}} seleccionats",
+  "bulkActions": {
+    "addToCase": "Afegeix al cas",
+    "moveToCase": "Mou al cas",
+    "removeFromCase": "Elimina del cas",
+    "delete": "Suprimeix",
+    "deleteNow": "Suprimeix ara"
+  },
+  "bulkDelete": {
+    "title": "Suprimeix les exportacions",
+    "desc_one": "Esteu segur que voleu suprimir {{count}} l'exportació?",
+    "desc_other": "steu segur que voleu suprimir {{count}} exportacions?"
+  },
+  "bulkRemoveFromCase": {
+    "title": "Elimina del cas",
+    "desc_one": "Voleu suprimir {{count}} d'aquest cas?",
+    "desc_other": "Voleu eliminar {{count}} exportacions d'aquest cas?",
+    "descKeepExports": "Les exportacions es mouran a sense categoria.",
+    "descDeleteExports": "Les exportacions s'eliminaran permanentment.",
+    "deleteExports": "Suprimeix les exportacions"
+  },
+  "bulkToast": {
+    "success": {
+      "delete": "Exportacions suprimides amb èxit",
+      "reassign": "Assignació de cas actualitzada amb èxit",
+      "remove": "S'han eliminat les exportacions del cas"
+    },
+    "error": {
+      "deleteFailed": "No s'han pogut suprimir les exportacions: {{errorMessage}}",
+      "reassignFailed": "No s'ha pogut actualitzar l'assignació de cas: {{errorMessage}}"
+    }
   }
 }

web/public/locales/ca/views/faceLibrary.json

@@ -38,7 +38,7 @@
     "uploadFace": "Puja una imatge del rostre",
     "nextSteps": "Següents passos",
     "description": {
-      "uploadFace": "Puja una imatge de {{name}} que mostri el seu rostre de cares. No cal que la imatge estigui retallada només al rostre."
+      "uploadFace": "Pugeu una imatge de {{name}} que mostra la seva cara des d'un angle frontal. La imatge no necessita ser retallada a la seva cara."
     }
   },
   "selectFace": "Seleccionar rostre",

web/public/locales/ca/views/settings.json

@@ -1280,7 +1280,8 @@
         },
         "hikvision": {
           "substreamWarning": "El substream 1 està bloquejat a una resolució baixa. Moltes càmeres Hikvision suporten subfluxos addicionals que han d'estar habilitats a la configuració de la càmera. Es recomana comprovar i utilitzar aquests corrents si estan disponibles."
-        }
+        },
+        "resolutionUnknown": "La resolució d'aquest flux no s'ha pogut investigar. Heu d'establir manualment la resolució de detecció a Configuració o a la configuració."
       }
     }
   },
@@ -1297,7 +1298,13 @@
       "enableDesc": "Inhabilita temporalment una càmera habilitada fins que es reiniciï Frigate. La inhabilitació d'una càmera atura completament el processament de Frigate dels fluxos d'aquesta càmera. La detecció, l'enregistrament i la depuració no estaran disponibles.<br /> <em>Nota: això no desactiva les retransmissions de go2rtc.</em>",
       "disableLabel": "Càmeres inhabilitades",
       "disableDesc": "Habilita una càmera que actualment no és visible a la interfície d'usuari i està desactivada a la configuració. Es requereix un reinici de Frigate després d'activar-la.",
-      "enableSuccess": "{{cameraName}} activat a la configuració. Reinicia Frigate per aplicar els canvis."
+      "enableSuccess": "{{cameraName}} activat a la configuració. Reinicia Frigate per aplicar els canvis.",
+      "friendlyName": {
+        "edit": "Edita el nom de la pantalla de la càmera",
+        "title": "Edita el nom de la pantalla",
+        "description": "Estableix el nom amigable que es mostra per a aquesta càmera a tota la interfície d'usuari de la Fragata. Deixeu-ho en blanc per utilitzar l'ID de la càmera.",
+        "rename": "Canvia el nom"
+      }
     },
     "cameraConfig": {
       "add": "Afegeix una càmera",
@@ -1659,7 +1666,16 @@
       "empty": "No hi ha etiquetes disponibles",
       "allNonAlertDetections": "Totes les activitats no alertes s'inclouran com a deteccions."
     },
-    "addCustomLabel": "Afegeix una etiqueta personalitzada..."
+    "addCustomLabel": "Afegeix una etiqueta personalitzada...",
+    "genaiModel": {
+      "placeholder": "Selecciona el model…",
+      "search": "Cerca models…",
+      "noModels": "No hi ha models disponibles"
+    },
+    "knownPlates": {
+      "namePlaceholder": "per exemple. Cotxe de la parella",
+      "platePlaceholder": "Matricula o regex"
+    }
   },
   "globalConfig": {
     "title": "Configuració global",

web/public/locales/de/components/dialog.json

@@ -64,20 +64,73 @@
     "toast": {
       "error": {
         "endTimeMustAfterStartTime": "Die Endzeit darf nicht vor der Startzeit liegen",
-        "failed": "Fehler beim Starten des Exports: {{error}}",
+        "failed": "Fehler beim Export in die Warteschlange: {{error}}",
         "noVaildTimeSelected": "Kein gültiger Zeitraum ausgewählt"
       },
       "success": "Export erfolgreich gestartet. Die Datei befindet sich auf der Exportseite.",
-      "view": "Ansicht"
+      "view": "Ansicht",
+      "queued": "Export in Warteschlange gestellt. Fortschritt auf der Exportseite verfolgen.",
+      "batchSuccess_one": "1 Export gestartet. Öffne den Fall jetzt.",
+      "batchSuccess_other": "{{count}} Exports gestartet. Öffne den Fall jetzt.",
+      "batchPartial": "{{successful}} von {{total}} Exporten gestartet. Fehlgeschlagene Kameras: {{failedCameras}}",
+      "batchFailed": "Fehler beim Starten der {{total}} Exporte. Fehlgeschlagene Kameras: {{failedCameras}}",
+      "batchQueuedSuccess_one": "1 Export in die Warteschlange gestellt. Fall wird jetzt geöffnet.",
+      "batchQueuedSuccess_other": "{{count}} Exporte in der Warteschlange. Fall wird jetzt geöffnet.",
+      "batchQueuedPartial": "{{successful}} von {{total}} Exporten in die Warteschlange gestellt. Fehlerhafte Kameras: {{failedCameras}}",
+      "batchQueueFailed": "Fehler beim Einreihen von {{total}} Exporten in die Warteschlange. Fehlerhafte Kameras: {{failedCameras}}"
     },
     "fromTimeline": {
       "saveExport": "Export speichern",
-      "previewExport": "Exportvorschau"
+      "previewExport": "Exportvorschau",
+      "queueingExport": "Export wird in die Warteschlange gestellt...",
+      "useThisRange": "Nutzen Sie diesen Bereich"
     },
     "export": "Exportieren",
     "case": {
       "label": "Fall",
-      "placeholder": "Einen Fall auswählen"
+      "placeholder": "Einen Fall auswählen",
+      "newCaseOption": "Einen neuen Fall erstellen",
+      "newCaseNamePlaceholder": "Neuer Fallname",
+      "newCaseDescriptionPlaceholder": "Fall Beschreibung",
+      "nonAdminHelp": "Für diese Exporte wird ein neuer Fall angelegt."
+    },
+    "queueing": "Export wird in die Warteschlange gestellt...",
+    "tabs": {
+      "export": "Einzelne Kamera",
+      "multiCamera": "Mehrere-Kameras"
+    },
+    "multiCamera": {
+      "timeRange": "Zeitbereich",
+      "selectFromTimeline": "Wählen Sie aus der Zeitleiste aus",
+      "cameraSelection": "Kameras",
+      "cameraSelectionHelp": "Kameras, die in diesem Zeitbereich Objekte verfolgen, sind vorausgewählt",
+      "checkingActivity": "Kameraaktivität wird überprüft...",
+      "noCameras": "keine kamaeras verfügbar",
+      "detectionCount_one": "1 verfolgtes Objekt",
+      "detectionCount_other": "{{count}} verfolgtesObjekte",
+      "nameLabel": "Export Name",
+      "namePlaceholder": "Optionaler Basisname für diese Exporte",
+      "queueingButton": "Exporte werden in die Warteschlange gestellt...",
+      "exportButton_one": "Export 1 Kamera",
+      "exportButton_other": "xport {{count}} Kameras"
+    },
+    "multi": {
+      "title_one": "1 Bewertung exportieren",
+      "title_other": "{{count}} Bewertung exportieren",
+      "description": "Exportieren Sie jede ausgewählte Rezension. Alle Exporte werden in einem einzigen Fall zusammengefasst.",
+      "descriptionNoCase": "Jede ausgewählte Bewertung exportieren.",
+      "caseNamePlaceholder": "Export prüfen - {{date}}",
+      "exportButton_one": "1 Bewertung exportieren",
+      "exportButton_other": "{{count}} Bewertung exportieren",
+      "exportingButton": "Exportieren...",
+      "toast": {
+        "started_one": "1 Export gestartet. Fall wird jetzt geöffnet.",
+        "started_other": "{{count}} Exporte gestartet. Fall wird jetzt geöffnet.",
+        "startedNoCase_one": "1 Export gestartet.",
+        "startedNoCase_other": "{{count}} Exports gestartet.",
+        "partial": "{{successful}} von {{total}} Exporten gestartet. Fehlgeschlagen: {{failedItems}}",
+        "failed": "Fehler beim Starten der {{total}} Exporte. Fehler: {{failedItems}}"
+      }
     }
   },
   "streaming": {

web/public/locales/de/config/global.json

@@ -1710,7 +1710,7 @@
         },
         "roles": {
             "label": "Rollen",
-            "description": "GenAI-Rollen (Tools, Vision, Einbettungen); ein Anbieter pro Rolle."
+            "description": "GenAI-Rollen (Nachrichten, Beschreibung, Einbettungen); ein Anbieter pro Rolle."
         },
         "provider_options": {
             "label": "Anbieter Optionen",

web/public/locales/de/views/explore.json

@@ -282,7 +282,10 @@
         "zones": "Zonen",
         "ratio": "Verhältnis",
         "area": "Bereich",
-        "score": "Bewertung"
+        "score": "Bewertung",
+        "computedScore": "Berechnetes Ergebnis",
+        "topScore": "Bester Treffer",
+        "toggleAdvancedScores": "Erweiterte Ergebnisse umschalten"
       }
     },
     "annotationSettings": {

web/public/locales/de/views/exports.json

@@ -14,7 +14,9 @@
   "toast": {
     "error": {
       "renameExportFailed": "Umbenennen des Exports fehlgeschlagen: {{errorMessage}}",
-      "assignCaseFailed": "Aktualisierung der Fallzuweisung fehlgeschlagen: {{errorMessage}}"
+      "assignCaseFailed": "Aktualisierung der Fallzuweisung fehlgeschlagen: {{errorMessage}}",
+      "caseSaveFailed": "Fehler beim speichern vom Fall: {{errorMessage}}",
+      "caseDeleteFailed": "Fehler beim löschem vom Fall: {{errorMessage}}"
     }
   },
   "tooltip": {
@@ -22,7 +24,8 @@
     "downloadVideo": "Video herunterladen",
     "editName": "Name ändern",
     "deleteExport": "Export löschen",
-    "assignToCase": "Hinzufügen zum Fall"
+    "assignToCase": "Hinzufügen zum Fall",
+    "removeFromCase": "Vom Gehäuse entfernen"
   },
   "headings": {
     "cases": "Fälle",
@@ -35,5 +38,91 @@
     "newCaseOption": "Neuen Fall erstellen",
     "nameLabel": "Fallname",
     "descriptionLabel": "Beschreibung"
+  },
+  "toolbar": {
+    "newCase": "Neuer Fall",
+    "addExport": "Zum expotieren hinzufügen",
+    "editCase": "Fall bearbeiten",
+    "deleteCase": "Fall löschen"
+  },
+  "deleteCase": {
+    "label": "Fall löschen",
+    "desc": "Sind sie sich sicher löschen von{{caseName}}?",
+    "descKeepExports": "Exporte bleiben als nicht kategorisierte Exporte verfügbar.",
+    "descDeleteExports": "Alle Exporte werden in diesem Fall endgültig gelöscht.",
+    "deleteExports": "Exporte auch löschen"
+  },
+  "caseCard": {
+    "emptyCase": "Noch keine Exporte"
+  },
+  "jobCard": {
+    "defaultName": "{{camera}} export",
+    "queued": "In der Warteschlange",
+    "running": "läuft",
+    "preparing": "Vorbereitung",
+    "copying": "kopieren",
+    "encoding": "Codierung",
+    "encodingRetry": "Kodierung (Wiederholung)",
+    "finalizing": "Abschließen"
+  },
+  "caseView": {
+    "noDescription": "keine Beschreibung",
+    "createdAt": "Erstellt {{value}}",
+    "exportCount_one": "1 Export",
+    "exportCount_other": "{{count}} Exports",
+    "cameraCount_one": "1 Kamera",
+    "cameraCount_other": "{{count}} Kameras",
+    "showMore": "Mehr anzeigen",
+    "showLess": "Weniger Anzeigen",
+    "emptyTitle": "Der Fall ist leer",
+    "emptyDescription": "Fügen Sie vorhandene, nicht kategorisierte Exporte hinzu, um den Fall übersichtlich zu halten.",
+    "emptyDescriptionNoExports": "Es sind noch keine nicht kategorisierten Exporte zum Hinzufügen verfügbar."
+  },
+  "caseEditor": {
+    "createTitle": "Fall erstellen",
+    "editTitle": "Fall bearbeiten",
+    "namePlaceholder": "Fall Name",
+    "descriptionPlaceholder": "Fügen Sie Anmerkungen oder Kontext zu diesem Fall hinzu"
+  },
+  "addExportDialog": {
+    "title": "Export zum {{caseName}} hinzufügen",
+    "searchPlaceholder": "Suche nach nicht kategorisierten Exporten",
+    "empty": "Es wurden keine nicht kategorisierten Exporte gefunden, die dieser Suche entsprechen.",
+    "addButton_one": "1 Export hinzufügen",
+    "addButton_other": "Fügen Sie {{count}} Exporte hinzu",
+    "adding": "Hinzufügen..."
+  },
+  "selected_one": "{{count}} ausgewählt",
+  "selected_other": "{{count}} ausgewählt",
+  "bulkActions": {
+    "addToCase": "Zum Fall hinzufügen",
+    "moveToCase": "Zum Fall wechseln",
+    "removeFromCase": "Aus dem Fall nehmen",
+    "delete": "löschen",
+    "deleteNow": "jetzt löschen"
+  },
+  "bulkDelete": {
+    "title": "Exporte löschen",
+    "desc_one": "Möchten Sie den Export {{count}} wirklich löschen?",
+    "desc_other": "Möchten Sie wirklich {{count}} Exporte löschen?"
+  },
+  "bulkRemoveFromCase": {
+    "title": "Aus dem Fall nehmen",
+    "desc_one": "{{count}}-Export aus diesem Fall entfernen?",
+    "desc_other": "{{count}} Exporte aus diesem Fall entfernen?",
+    "descKeepExports": "Die Exporte werden in die Kategorie „Nicht kategorisiert“ verschoben.",
+    "descDeleteExports": "Exporte werden endgültig gelöscht.",
+    "deleteExports": "Löschen Sie stattdessen Exporte"
+  },
+  "bulkToast": {
+    "success": {
+      "delete": "Exporte erfolgreich gelöscht",
+      "reassign": "Fallzuweisung erfolgreich aktualisiert",
+      "remove": "Exporte erfolgreich aus dem Fall entfernt"
+    },
+    "error": {
+      "deleteFailed": "Fehler beim Löschen der Exporte: {{errorMessage}}",
+      "reassignFailed": "Fehler beim Aktualisieren der Fallzuordnung: {{errorMessage}}"
+    }
   }
 }

web/public/locales/de/views/settings.json

@@ -345,6 +345,10 @@
           "zone": "Zone",
           "motion_mask": "Bewegungsmaske",
           "object_mask": "Objektmaske"
+        },
+        "revertOverride": {
+          "title": "Basis Konfiguration wiederherstellen",
+          "desc": "Dadurch wird die Profilüberschreibung für {{type}}<em>{{name}}</em> aufgehoben und die Grundkonfiguration wiederhergestellt."
         }
       },
       "speed": {
@@ -507,7 +511,8 @@
         "title": "Aktiviert",
         "description": "Ob diese Maske in der Konfigurationsdatei aktiviert ist. Ist sie deaktiviert, kann sie nicht über MQTT aktiviert werden. Deaktivierte Masken werden zur Laufzeit ignoriert."
       }
-    }
+    },
+    "addDisabledProfile": "Fügen Sie es zuerst der Basiskonfiguration hinzu und überschreiben Sie es dann im Profil"
   },
   "debug": {
     "objectShapeFilterDrawing": {
@@ -1647,7 +1652,8 @@
       "keyDuplicate": "Der Name des Detektors ist bereits vorhanden.",
       "noSchema": "Es sind keine Detektorschemata verfügbar.",
       "none": "Es sind keine Detektorinstanzen konfiguriert.",
-      "add": "Detektor hinzufügen"
+      "add": "Detektor hinzufügen",
+      "addCustomKey": "Benutzerdefinierten Schlüssel hinzufügen"
     },
     "record": {
       "title": "Aufnahmeeinstellungen"
@@ -1718,7 +1724,16 @@
       "title": "Einstellungen für Zeitstempel"
     },
     "searchPlaceholder": "Suche...",
-    "addCustomLabel": "Benutzerdefiniertes Etikett hinzufügen..."
+    "addCustomLabel": "Benutzerdefiniertes Etikett hinzufügen...",
+    "knownPlates": {
+      "namePlaceholder": "z.B. das Auto der Frau",
+      "platePlaceholder": "Kennzeichen oder regulärer Ausdruck"
+    },
+    "genaiModel": {
+      "placeholder": "Modell auswählen…",
+      "search": "Modell suchen…",
+      "noModels": "Keine Modelle verfügbar"
+    }
   },
   "globalConfig": {
     "title": "Globale Konfiguration",
@@ -1876,6 +1891,10 @@
     },
     "snapshots": {
       "detectDisabled": "Die Objekterkennung ist deaktiviert. Es werden keine Momentaufnahmen von verfolgten Objekten erstellt."
+    },
+    "detectors": {
+      "mixedTypes": "Alle Detektoren müssen von gleichem Typ sein, Entferne bestehende Detektoren um einen anderen Typ zu benutzen.",
+      "mixedTypesSuggestion": "Alle Detektoren müssen vom gleichem Typ sein. Entferne bestehende oder wähle {{type}}."
     }
   }
 }

web/public/locales/el/config/global.json

@@ -1 +1,14 @@
-{}
+{
+    "version": {
+        "label": "Τρέχουσα έκδοση διαμόρφωσης"
+    },
+    "safe_mode": {
+        "label": "Ασφαλής λειτουργία"
+    },
+    "auth": {
+        "reset_admin_password": {
+            "label": "Επανέφερε κωδικού πρόσβασης για τον διαχειριστή admin",
+            "description": "Άμα είναι αλήθεια, επαναφέρει τον κωδικό πρόσβασης του χρήστη διαχειριστή(admin) κατά την εκκίνηση και εκτύπωση του νέου κωδικού πρόσβασης στα αρχείο καταγραφής(logs)"
+        }
+    }
+}

web/public/locales/en/config/global.json

@@ -397,6 +397,14 @@
         "description": "The device to use for Hailo inference (e.g. 'PCIe', 'M.2')."
       }
     },
+    "hailo10h": {
+      "label": "Hailo-10H",
+      "description": "Hailo-10H detector using HEF models and the HailoRT SDK for inference on Hailo hardware.",
+      "device": {
+        "label": "Device Type",
+        "description": "The device to use for Hailo inference (e.g. 'PCIe', 'M.2')."
+      }
+    },   
     "memryx": {
       "label": "MemryX",
       "description": "MemryX MX3 detector that runs compiled DFP models on MemryX accelerators.",

web/public/locales/es/common.json

@@ -195,7 +195,8 @@
     "explore": "Explorar",
     "uiPlayground": "Zona de pruebas de la interfaz de usuario",
     "faceLibrary": "Biblioteca de rostros",
-    "classification": "Clasificación"
+    "classification": "Clasificación",
+    "profiles": "Perfiles"
   },
   "unit": {
     "speed": {

web/public/locales/es/components/dialog.json

@@ -77,7 +77,11 @@
       "saveExport": "Guardar exportación",
       "previewExport": "Vista previa de la exportación"
     },
-    "selectOrExport": "Seleccionar o exportar"
+    "selectOrExport": "Seleccionar o exportar",
+    "case": {
+      "label": "Caso",
+      "newCaseDescriptionPlaceholder": "Descripción de caso"
+    }
   },
   "streaming": {
     "restreaming": {
@@ -124,6 +128,9 @@
       "markAsReviewed": "Marcar como revisado",
       "deleteNow": "Eliminar ahora",
       "markAsUnreviewed": "Marcar como no revisado"
+    },
+    "shareTimestamp": {
+      "description": "Comparta una URL con marca de tiempo de la posición actual del reproductor o elija una marca de tiempo personalizada. Tenga en cuenta que esta no es una URL pública para compartir y solo es accesible para los usuarios que tienen acceso a Frigate y a esta cámara."
     }
   },
   "imagePicker": {

web/public/locales/es/components/player.json

@@ -3,7 +3,8 @@
   "noPreviewFoundFor": "No se encontró vista previa para {{cameraName}}",
   "submitFrigatePlus": {
     "submit": "Enviar",
-    "title": "¿Enviar este fotograma a Frigate+?"
+    "title": "¿Enviar este fotograma a Frigate+?",
+    "previewError": "No se pudo cargar la vista previa de la instantánea. Es posible que la grabación no esté disponible en este momento."
   },
   "streamOffline": {
     "desc": "No se han recibido fotogramas en la transmisión <code>detect</code> de {{cameraName}}, revisa los registros de errores",

web/public/locales/es/config/cameras.json

@@ -42,10 +42,32 @@
         "label": "Nombre descriptivo",
         "description": "Nombre descriptivo de la cámara utilizado en la interfaz de usuario de Frigate"
     },
-    "label": "Configuración de Cámara",
+    "label": "Configuración de cámara",
     "onvif": {
         "profile": {
-            "label": "Perfil ONVIF"
+            "label": "Perfil ONVIF",
+            "description": "Perfil multimedia ONVIF específico que se utilizará para el control PTZ, identificado por token o nombre. Si no se especifica, se selecciona automáticamente el primer perfil con una configuración PTZ válida."
+        },
+        "autotracking": {
+            "zoom_factor": {
+                "description": "Controla el nivel de zoom en los objetos rastreados. Los valores más bajos mantienen una mayor parte de la escena a la vista; los valores más altos acercan la imagen, pero pueden provocar la pérdida del rastreo. Valores entre 0.1 y 0.75."
+            },
+            "calibrate_on_startup": {
+                "description": "Mida la velocidad de los motores PTZ al encenderlos para mejorar la precisión del seguimiento. Frigate actualizará la configuración con los `movement_weights` tras la calibración."
+            },
+            "description": "Realice un seguimiento automático de objetos en movimiento y manténgalos centrados en el encuadre mediante movimientos de cámara PTZ.",
+            "zooming": {
+                "description": "Control del comportamiento del zoom: deshabilitado (solo panorámica/inclinación), absoluto (mayor compatibilidad) o relativo (panorámica/inclinación/zoom simultáneos)."
+            },
+            "return_preset": {
+                "description": "Nombre del preajuste ONVIF configurado en el firmware de la cámara al que regresar una vez finalizado el seguimiento."
+            },
+            "timeout": {
+                "description": "Espere esta cantidad de segundos después de perder el seguimiento antes de devolver la cámara a la posición preestablecida."
+            }
+        },
+        "tls_insecure": {
+            "description": "Omitir la verificación TLS y deshabilitar la autenticación digest para ONVIF (no seguro; usar solo en redes seguras)."
         }
     },
     "zones": {
@@ -83,7 +105,24 @@
             "max_area": {
                 "description": "Área máxima del cuadro delimitador (píxeles o porcentaje) permitida para este tipo de objeto. Puede expresarse en píxeles (entero) o como porcentaje (decimal entre 0,000001 y 0,99).",
                 "label": "Área máxima del objeto"
-            }
+            },
+            "description": "Filtros para aplicar a los objetos dentro de esta zona. Se utilizan para reducir los falsos positivos o restringir qué objetos se consideran presentes en la zona."
+        },
+        "objects": {
+            "description": "Lista de tipos de objetos (del mapa de etiquetas) que pueden activar esta zona. Puede ser una cadena de texto o una lista de cadenas. Si está vacío, se consideran todos los objetos."
+        },
+        "description": "Las zonas le permiten definir un área específica del fotograma, de modo que pueda determinar si un objeto se encuentra o no dentro de un área determinada.",
+        "speed_threshold": {
+            "description": "Velocidad mínima (en unidades del mundo real, si se han configurado distancias) requerida para que un objeto se considere presente en la zona. Se utiliza para los disparadores de zona basados en la velocidad."
+        },
+        "friendly_name": {
+            "description": "Un nombre fácil de usar para la zona, que se muestra en la interfaz de usuario de Frigate. Si no se especifica, se utilizará una versión formateada del nombre de la zona."
+        },
+        "inertia": {
+            "description": "Número de fotogramas consecutivos en los que se debe detectar un objeto dentro de la zona antes de considerarlo presente. Ayuda a filtrar las detecciones transitorias."
+        },
+        "loitering_time": {
+            "description": "Número de segundos que un objeto debe permanecer en la zona para ser considerado como merodeo. Establezca en 0 para desactivar la detección de merodeo."
         }
     },
     "objects": {
@@ -100,7 +139,151 @@
             "use_snapshot": {
                 "label": "Usar instantáneas",
                 "description": "Usar instantáneas de objetos en lugar de miniaturas para la generación de descripciones de GenAI."
+            },
+            "send_triggers": {
+                "after_significant_updates": {
+                    "description": "Envía una solicitud a GenAI tras un número especificado de actualizaciones significativas del objeto rastreado."
+                },
+                "description": "Define cuándo se deben enviar los fotogramas a GenAI (al finalizar, después de las actualizaciones, etc.)."
+            },
+            "required_zones": {
+                "description": "Zonas en las que deben ubicarse los objetos para ser elegibles para la generación de descripciones con GenAI."
             }
         }
+    },
+    "mqtt": {
+        "label": "MQTT",
+        "required_zones": {
+            "description": "Zonas en las que debe entrar un objeto para que se publique una imagen MQTT."
+        }
+    },
+    "notifications": {
+        "email": {
+            "label": "Email de notificacion"
+        }
+    },
+    "audio_transcription": {
+        "description": "Configuración para la transcripción de audio en vivo y de voz, utilizada para eventos y subtítulos en tiempo real.",
+        "enabled": {
+            "label": "Habilitar transcripción"
+        }
+    },
+    "motion": {
+        "skip_motion_threshold": {
+            "description": "Si se establece en un valor entre 0,0 y 1,0, y más de esta fracción de la imagen cambia en un solo fotograma, el detector no devolverá cuadros de movimiento y se recalibrará inmediatamente. Esto puede ahorrar recursos de CPU y reducir los falsos positivos durante tormentas eléctricas, tempestades, etc., aunque podría pasar por alto eventos reales, como el seguimiento automático de un objeto por parte de una cámara PTZ. La disyuntiva está entre descartar unos cuantos megabytes de grabaciones o revisar un par de clips cortos. Deje este parámetro sin establecer (None) para desactivar esta función."
+        },
+        "lightning_threshold": {
+            "description": "Umbral para detectar e ignorar breves picos de luz (un valor menor indica mayor sensibilidad; valores entre 0,3 y 1,0). Esto no impide por completo la detección de movimiento; Simplemente provoca que el detector deje de analizar fotogramas adicionales una vez que se supera el umbral. Durante estos eventos aún se realizan grabaciones basadas en el movimiento."
+        },
+        "threshold": {
+            "description": "Umbral de diferencia de píxeles utilizado por el detector de movimiento; los valores más altos reducen la sensibilidad (rango 1-255)."
+        }
+    },
+    "lpr": {
+        "enhancement": {
+            "description": "Nivel de mejora (0-10) que se aplicará a los recortes de matrículas antes del OCR; los valores más altos no siempre mejoran los resultados, y los niveles superiores a 5 podrían funcionar únicamente con matrículas capturadas de noche, por lo que deben utilizarse con precaución."
+        },
+        "expire_time": {
+            "description": "Tiempo en segundos tras el cual una matrícula no detectada caduca en el sistema de seguimiento (solo para cámaras LPR dedicadas)."
+        }
+    },
+    "detect": {
+        "fps": {
+            "description": "Fotogramas por segundo deseados para ejecutar la detección; los valores más bajos reducen el uso de la CPU (el valor recomendado es 5; establezca un valor superior —como máximo de 10— únicamente si realiza el seguimiento de objetos que se mueven con extrema rapidez)."
+        },
+        "min_initialized": {
+            "description": "Número de detecciones consecutivas requeridas antes de crear un objeto rastreado. Auméntelo para reducir las inicializaciones falsas. El valor predeterminado es los FPS divididos por 2."
+        },
+        "height": {
+            "description": "Altura (en píxeles) de los fotogramas utilizados para la transmisión de detección; déjelo vacío para utilizar la resolución nativa de la transmisión."
+        },
+        "width": {
+            "description": "Ancho (en píxeles) de los fotogramas utilizados para la transmisión de detección; déjelo vacío para utilizar la resolución nativa de la transmisión."
+        },
+        "stationary": {
+            "description": "Configuración para detectar y gestionar objetos que permanecen inmóviles durante un periodo de tiempo."
+        }
+    },
+    "record": {
+        "motion": {
+            "description": "Número de días para conservar las grabaciones activadas por movimiento, independientemente de los objetos rastreados. Establézcalo en 0 si solo desea conservar las grabaciones de alertas y detecciones."
+        },
+        "continuous": {
+            "description": "Número de días para conservar las grabaciones, independientemente de los objetos rastreados o del movimiento. Establézcalo en 0 si solo desea conservar las grabaciones de alertas y detecciones."
+        },
+        "detections": {
+            "pre_capture": {
+                "description": "Número de segundos antes del evento de detección que se incluirán en la grabación."
+            },
+            "post_capture": {
+                "description": "Número de segundos después del evento de detección que se incluirán en la grabación."
+            }
+        },
+        "alerts": {
+            "pre_capture": {
+                "description": "Número de segundos antes del evento de detección que se incluirán en la grabación."
+            },
+            "post_capture": {
+                "description": "Número de segundos después del evento de detección que se incluirán en la grabación."
+            }
+        }
+    },
+    "ui": {
+        "dashboard": {
+            "description": "Alterna si esta cámara es visible en toda la interfaz de usuario de Frigate. Desactivar esta opción requerirá editar manualmente la configuración para volver a visualizar esta cámara en la interfaz."
+        }
+    },
+    "live": {
+        "height": {
+            "description": "Altura (en píxeles) para renderizar la transmisión en vivo de jsmpeg en la interfaz web; debe ser <= a la altura de la transmisión de detección."
+        },
+        "description": "Configuraciones utilizadas por la interfaz web para controlar la selección, la resolución y la calidad de transmisiónes en vivo."
+    },
+    "review": {
+        "description": "Configuraciones que controlan las alertas, las detecciones y los resúmenes de revisión de GenAI utilizados por la interfaz de usuario y el almacenamiento de esta cámara.",
+        "alerts": {
+            "required_zones": {
+                "description": "Zonas en las que debe entrar un objeto para ser considerado una alerta; dejar vacío para permitir cualquier zona."
+            },
+            "labels": {
+                "description": "Lista de etiquetas de objetos que califican como alertas (por ejemplo: car, person)."
+            }
+        },
+        "detections": {
+            "required_zones": {
+                "description": "Zonas en las que debe entrar un objeto para ser considerado detectado; dejar vacío para permitir cualquier zona."
+            },
+            "description": "Configuración para determinar qué objetos rastreados generan detecciones (no alertas) y cómo se retienen dichas detecciones."
+        },
+        "genai": {
+            "image_source": {
+                "description": "Fuente de las imágenes enviadas a GenAI ('preview' o 'recordings'); La opción 'recordings' utiliza fotogramas de mayor calidad, pero requiere más tokens."
+            },
+            "additional_concerns": {
+                "description": "Una lista de preocupaciones o notas adicionales que GenAI debería tener en cuenta al evaluar la actividad en esta cámara."
+            },
+            "activity_context_prompt": {
+                "description": "Instrucción personalizada que describe qué constituye y qué no una actividad sospechosa, con el fin de proporcionar contexto para los resúmenes generados por GenAI."
+            },
+            "description": "Controla el uso de IA generativa (GenAI) para la elaboración de descripciones y resúmenes de elementos de revisión.",
+            "debug_save_thumbnails": {
+                "description": "Guarde las miniaturas que se envían al proveedor de GenAI para su depuración y revisión."
+            }
+        }
+    },
+    "birdseye": {
+        "description": "Configuración para la vista compuesta Birdseye, que combina las transmisiones de múltiples cámaras en una sola vista."
+    },
+    "ffmpeg": {
+        "retry_interval": {
+            "description": "Segundos de espera antes de intentar reconectar la transmisión de una cámara tras un fallo. El valor predeterminado es 10."
+        },
+        "path": {
+            "description": "Ruta al binario de FFmpeg que se va a utilizar o un alias de versión (\"5.0\" o \"7.0\")."
+        },
+        "output_args": {
+            "description": "Argumentos de salida predeterminados utilizados para diferentes roles de FFmpeg, tales como detección y grabación."
+        },
+        "description": "Configuración de FFmpeg, incluyendo la ruta del binario, argumentos, opciones de aceleración por hardware y argumentos de salida por rol."
     }
 }

web/public/locales/es/config/global.json

@@ -70,11 +70,45 @@
         "cookie_secure": {
             "label": "Flag de cookie segura",
             "description": "Establece el flag de seguridad en la cookie de autenticación; debe ser 'true' cuando se utilice TLS."
+        },
+        "failed_login_rate_limit": {
+            "label": "Limite de intento de acceso fallidos"
+        },
+        "session_length": {
+            "description": "Duración de la sesión en segundos para sesiones de JWT."
+        },
+        "admin_first_time_login": {
+            "description": "Cuando se establece en true, la interfaz de usuario puede mostrar un enlace de ayuda en la página de inicio de sesión, informando a los usuarios sobre cómo iniciar sesión tras el restablecimiento de la contraseña de administrador. "
+        },
+        "refresh_time": {
+            "description": "Cuando a una sesión le queden menos de esta cantidad de segundos para expirar, actualícela para restablecer su duración completa."
         }
     },
     "onvif": {
         "profile": {
-            "label": "Perfil ONVIF"
+            "label": "Perfil ONVIF",
+            "description": "Perfil multimedia ONVIF específico que se utilizará para el control PTZ, identificado por token o nombre. Si no se especifica, se selecciona automáticamente el primer perfil con una configuración PTZ válida."
+        },
+        "autotracking": {
+            "zoom_factor": {
+                "description": "Controla el nivel de zoom en los objetos rastreados. Los valores más bajos mantienen una mayor parte de la escena a la vista; los valores más altos acercan la imagen, pero pueden provocar la pérdida del rastreo. Valores entre 0.1 y 0.75."
+            },
+            "calibrate_on_startup": {
+                "description": "Mida la velocidad de los motores PTZ al encenderlos para mejorar la precisión del seguimiento. Frigate actualizará la configuración con los `movement_weights` tras la calibración."
+            },
+            "description": "Realice un seguimiento automático de objetos en movimiento y manténgalos centrados en el encuadre mediante movimientos de cámara PTZ.",
+            "zooming": {
+                "description": "Control del comportamiento del zoom: deshabilitado (solo panorámica/inclinación), absoluto (mayor compatibilidad) o relativo (panorámica/inclinación/zoom simultáneos)."
+            },
+            "return_preset": {
+                "description": "Nombre del preajuste ONVIF configurado en el firmware de la cámara al que regresar una vez finalizado el seguimiento."
+            },
+            "timeout": {
+                "description": "Espere esta cantidad de segundos después de perder el seguimiento antes de devolver la cámara a la posición preestablecida."
+            }
+        },
+        "tls_insecure": {
+            "description": "Omitir la verificación TLS y deshabilitar la autenticación digest para ONVIF (no seguro; usar solo en redes seguras)."
         }
     },
     "objects": {
@@ -91,7 +125,19 @@
             "use_snapshot": {
                 "label": "Usar instantáneas",
                 "description": "Usar instantáneas de objetos en lugar de miniaturas para la generación de descripciones de GenAI."
+            },
+            "send_triggers": {
+                "after_significant_updates": {
+                    "description": "Envía una solicitud a GenAI tras un número especificado de actualizaciones significativas del objeto rastreado."
+                },
+                "description": "Define cuándo se deben enviar los fotogramas a GenAI (al finalizar, después de las actualizaciones, etc.)."
+            },
+            "required_zones": {
+                "description": "Zonas en las que deben ubicarse los objetos para ser elegibles para la generación de descripciones con GenAI."
             }
+        },
+        "track": {
+            "description": "Lista de etiquetas de objetos a rastrear para todas las cámaras; puede anularse por cámara."
         }
     },
     "detectors": {
@@ -107,6 +153,310 @@
             "api_key": {
                 "label": "Clave de API de DeepStack (si es necesaria)"
             }
+        },
+        "type": {
+            "label": "Tipo"
+        },
+        "label": "Detector de hardware",
+        "cpu": {
+            "label": "CPU",
+            "num_threads": {
+                "label": "Número de hilos para detección"
+            },
+            "description": "Detector TFLite de CPU que ejecuta modelos de TensorFlow Lite en la CPU del host sin aceleración por hardware. No recomendado."
+        },
+        "axengine": {
+            "label": "Motor AX NPU"
+        },
+        "teflon_tfl": {
+            "description": "Detector de delegados Teflon para TFLite, que utiliza la biblioteca de delegados Mesa Teflon para acelerar la inferencia en las GPU compatibles."
+        },
+        "synaptics": {
+            "description": "Detector NPU de Synaptics para modelos en formato .synap, utilizando el Synap SDK en hardware de Synaptics."
+        },
+        "zmq": {
+            "description": "Detector ZMQ IPC que descarga la inferencia a un proceso externo a través de un punto de conexión IPC de ZeroMQ."
+        },
+        "hailo8l": {
+            "description": "Detector Hailo-8/Hailo-8L que utiliza modelos HEF y el SDK HailoRT para la inferencia en hardware Hailo."
+        },
+        "onnx": {
+            "description": "Detector ONNX para ejecutar modelos ONNX; utilizará los backends de aceleración disponibles (CUDA/ROCm/OpenVINO) cuando estén disponibles."
+        },
+        "description": "Configuración para detectores de objetos (backends de CPU, GPU y ONNX) y cualquier ajuste del modelo específico del detector.",
+        "openvino": {
+            "description": "Detector OpenVINO para CPU AMD e Intel, GPU Intel y hardware VPU Intel."
+        },
+        "tensorrt": {
+            "description": "Detector TensorRT para dispositivos Nvidia Jetson que utiliza motores TensorRT serializados para una inferencia acelerada."
+        },
+        "degirum": {
+            "description": "Detector DeGirum para ejecutar modelos a través de la nube de DeGirum o servicios de inferencia local."
+        },
+        "rknn": {
+            "description": "Detector RKNN para NPUs de Rockchip; ejecuta modelos compilados para RKNN en hardware de Rockchip."
+        }
+    },
+    "database": {
+        "label": "Base de datos",
+        "description": "Configuración de la base de datos SQLite utilizada por Frigate para almacenar los metadatos de los objetos rastreados y las grabaciones."
+    },
+    "mqtt": {
+        "label": "MQTT",
+        "port": {
+            "label": "Puerto MQTT"
+        },
+        "tls_client_cert": {
+            "label": "Certificado cliente"
+        },
+        "description": "Configuración para conectar y publicar telemetría, instantáneas y detalles de eventos en un broker MQTT.",
+        "topic_prefix": {
+            "description": "Prefijo del tema MQTT para todos los temas de Frigate; debe ser único si se ejecutan múltiples instancias."
+        },
+        "client_id": {
+            "description": "Identificador de cliente utilizado al conectarse al broker MQTT; debe ser único para cada instancia."
+        }
+    },
+    "notifications": {
+        "email": {
+            "label": "Email de notificacion"
+        }
+    },
+    "networking": {
+        "ipv6": {
+            "label": "Configuración IPV6"
+        },
+        "listen": {
+            "internal": {
+                "label": "Puerto interno"
+            },
+            "external": {
+                "label": "Puerto externo",
+                "description": "Puerto externo de escucha para Frigate (por defecto 8791)."
+            },
+            "description": "Configuración de los puertos de escucha internos y externos. Esto es para usuarios avanzados. Para la mayoría de los casos de uso, se recomienda modificar la sección de puertos de su configuración de Docker Compose."
+        }
+    },
+    "proxy": {
+        "label": "Proxy",
+        "separator": {
+            "label": "Carácter de separación"
+        },
+        "default_role": {
+            "description": "Rol predeterminado asignado a los usuarios autenticados por proxy cuando no se aplica ningún mapeo de roles (administrador o espectador)."
+        },
+        "description": "Configuración para integrar Frigate detrás de un proxy inverso que transmite encabezados de usuario autenticados.",
+        "header_map": {
+            "description": "Mapear los encabezados de proxy entrantes a los campos de usuario y rol de Frigate para la autenticación basada en proxy.",
+            "role": {
+                "description": "Encabezado que contiene el rol o los grupos del usuario autenticado provenientes del proxy ascendente."
+            }
+        }
+    },
+    "telemetry": {
+        "label": "Telemetria",
+        "stats": {
+            "intel_gpu_stats": {
+                "label": "Estadísticas GPU Intel",
+                "description": "Habilitar la recopilación de estadísticas de la GPU Intel si hay una GPU Intel presente."
+            },
+            "network_bandwidth": {
+                "label": "Ancho de banda"
+            },
+            "amd_gpu_stats": {
+                "label": "Estadísticas GPU Amd",
+                "description": "Habilitar la recopilación de estadísticas de la GPU AMD si hay una GPU AMD presente."
+            },
+            "intel_gpu_device": {
+                "description": "Identificador de dispositivo utilizado al tratar las GPU Intel como SR-IOV para corregir las estadísticas de la GPU."
+            }
+        },
+        "version_check": {
+            "description": "Habilite una verificación saliente para detectar si hay disponible una versión más reciente de Frigate."
+        }
+    },
+    "ui": {
+        "timezone": {
+            "label": "Uso horario",
+            "description": "Zona horaria opcional que se mostrará en la interfaz de usuario (si no se especifica, se utilizará la hora local del navegador)."
+        },
+        "unit_system": {
+            "label": "Unidad de sistema",
+            "description": "Sistema de unidades para la visualización (métrico o imperial) utilizado en la interfaz de usuario y en MQTT."
+        }
+    },
+    "audio_transcription": {
+        "description": "Configuración para la transcripción de audio en vivo y de voz, utilizada para eventos y subtítulos en tiempo real.",
+        "language": {
+            "description": "Código de idioma utilizado para la transcripción/traducción (por ejemplo, 'es' para Español). Consulte https://whisper-api.com/docs/languages/ para ver los códigos de idioma compatibles."
+        },
+        "enabled": {
+            "description": "Habilitar o deshabilitar la transcripción automática de audio para todas las cámaras; puede anularse por cámara."
+        }
+    },
+    "motion": {
+        "skip_motion_threshold": {
+            "description": "Si se establece en un valor entre 0,0 y 1,0, y más de esta fracción de la imagen cambia en un solo fotograma, el detector no devolverá cuadros de movimiento y se recalibrará inmediatamente. Esto puede ahorrar recursos de CPU y reducir los falsos positivos durante tormentas eléctricas, tempestades, etc., aunque podría pasar por alto eventos reales, como el seguimiento automático de un objeto por parte de una cámara PTZ. La disyuntiva está entre descartar unos cuantos megabytes de grabaciones o revisar un par de clips cortos. Deje este parámetro sin establecer (None) para desactivar esta función."
+        },
+        "lightning_threshold": {
+            "description": "Umbral para detectar e ignorar breves picos de luz (un valor menor indica mayor sensibilidad; valores entre 0,3 y 1,0). Esto no impide por completo la detección de movimiento; Simplemente provoca que el detector deje de analizar fotogramas adicionales una vez que se supera el umbral. Durante estos eventos aún se realizan grabaciones basadas en el movimiento."
+        },
+        "threshold": {
+            "description": "Umbral de diferencia de píxeles utilizado por el detector de movimiento; los valores más altos reducen la sensibilidad (rango 1-255)."
+        },
+        "enabled": {
+            "description": "Habilitar o deshabilitar la detección de movimiento para todas las cámaras; puede anularse para cada cámara individualmente."
+        }
+    },
+    "lpr": {
+        "enhancement": {
+            "description": "Nivel de mejora (0-10) que se aplicará a los recortes de matrículas antes del OCR; los valores más altos no siempre mejoran los resultados, y los niveles superiores a 5 podrían funcionar únicamente con matrículas capturadas de noche, por lo que deben utilizarse con precaución."
+        },
+        "expire_time": {
+            "description": "Tiempo en segundos tras el cual una matrícula no detectada caduca en el sistema de seguimiento (solo para cámaras LPR dedicadas)."
+        },
+        "enabled": {
+            "description": "Habilitar o deshabilitar el reconocimiento de matrículas para todas las cámaras; puede anularse por cámara."
+        },
+        "min_plate_length": {
+            "description": "Número mínimo de caracteres que debe contener una matrícula reconocida para ser considerada válida."
+        }
+    },
+    "detect": {
+        "fps": {
+            "description": "Fotogramas por segundo deseados para ejecutar la detección; los valores más bajos reducen el uso de la CPU (el valor recomendado es 5; establezca un valor superior —como máximo de 10— únicamente si realiza el seguimiento de objetos que se mueven con extrema rapidez)."
+        },
+        "min_initialized": {
+            "description": "Número de detecciones consecutivas requeridas antes de crear un objeto rastreado. Auméntelo para reducir las inicializaciones falsas. El valor predeterminado es los FPS divididos por 2."
+        },
+        "height": {
+            "description": "Altura (en píxeles) de los fotogramas utilizados para la transmisión de detección; déjelo vacío para utilizar la resolución nativa de la transmisión."
+        },
+        "width": {
+            "description": "Ancho (en píxeles) de los fotogramas utilizados para la transmisión de detección; déjelo vacío para utilizar la resolución nativa de la transmisión."
+        },
+        "stationary": {
+            "description": "Configuración para detectar y gestionar objetos que permanecen inmóviles durante un periodo de tiempo."
+        },
+        "enabled": {
+            "description": "Habilitar o deshabilitar la detección de objetos para todas las cámaras; puede anularse para cada cámara individualmente."
+        }
+    },
+    "record": {
+        "motion": {
+            "description": "Número de días para conservar las grabaciones activadas por movimiento, independientemente de los objetos rastreados. Establézcalo en 0 si solo desea conservar las grabaciones de alertas y detecciones."
+        },
+        "continuous": {
+            "description": "Número de días para conservar las grabaciones, independientemente de los objetos rastreados o del movimiento. Establézcalo en 0 si solo desea conservar las grabaciones de alertas y detecciones."
+        },
+        "detections": {
+            "pre_capture": {
+                "description": "Número de segundos antes del evento de detección que se incluirán en la grabación."
+            },
+            "post_capture": {
+                "description": "Número de segundos después del evento de detección que se incluirán en la grabación."
+            }
+        },
+        "alerts": {
+            "pre_capture": {
+                "description": "Número de segundos antes del evento de detección que se incluirán en la grabación."
+            },
+            "post_capture": {
+                "description": "Número de segundos después del evento de detección que se incluirán en la grabación."
+            }
+        }
+    },
+    "camera_ui": {
+        "dashboard": {
+            "description": "Alterna si esta cámara es visible en toda la interfaz de usuario de Frigate. Desactivar esta opción requerirá editar manualmente la configuración para volver a visualizar esta cámara en la interfaz."
+        }
+    },
+    "live": {
+        "description": "Configuración para controlar la resolución y la calidad de la transmisión en vivo de jsmpeg. Esto no afecta a las cámaras retransmitidas que utilizan go2rtc para la visualización en vivo.",
+        "height": {
+            "description": "Altura (en píxeles) para renderizar la transmisión en vivo de jsmpeg en la interfaz web; debe ser <= a la altura de la transmisión de detección."
+        }
+    },
+    "semantic_search": {
+        "model": {
+            "description": "El modelo de embeddings a utilizar para la búsqueda semántica (por ejemplo, 'jinav1'), o el nombre de un proveedor de GenAI con el rol de embeddings."
+        }
+    },
+    "review": {
+        "alerts": {
+            "required_zones": {
+                "description": "Zonas en las que debe entrar un objeto para ser considerado una alerta; dejar vacío para permitir cualquier zona."
+            },
+            "labels": {
+                "description": "Lista de etiquetas de objetos que califican como alertas (por ejemplo: car, person)."
+            }
+        },
+        "detections": {
+            "required_zones": {
+                "description": "Zonas en las que debe entrar un objeto para ser considerado detectado; dejar vacío para permitir cualquier zona."
+            },
+            "description": "Configuración para determinar qué objetos rastreados generan detecciones (no alertas) y cómo se retienen dichas detecciones."
+        },
+        "genai": {
+            "image_source": {
+                "description": "Fuente de las imágenes enviadas a GenAI ('preview' o 'recordings'); La opción 'recordings' utiliza fotogramas de mayor calidad, pero requiere más tokens."
+            },
+            "additional_concerns": {
+                "description": "Una lista de preocupaciones o notas adicionales que GenAI debería tener en cuenta al evaluar la actividad en esta cámara."
+            },
+            "activity_context_prompt": {
+                "description": "Instrucción personalizada que describe qué constituye y qué no una actividad sospechosa, con el fin de proporcionar contexto para los resúmenes generados por GenAI."
+            },
+            "description": "Controla el uso de IA generativa (GenAI) para la elaboración de descripciones y resúmenes de elementos de revisión.",
+            "debug_save_thumbnails": {
+                "description": "Guarde las miniaturas que se envían al proveedor de GenAI para su depuración y revisión."
+            }
+        }
+    },
+    "birdseye": {
+        "description": "Configuración para la vista compuesta Birdseye, que combina las transmisiones de múltiples cámaras en una sola vista.",
+        "restream": {
+            "description": "Retransmita la salida de video de Birdseye como una transmisión en vivo RTSP; al habilitar esta opción, Birdseye se mantendrá en ejecución de forma continua."
+        },
+        "layout": {
+            "max_cameras": {
+                "description": "Número máximo de cámaras a mostrar simultáneamente en Birdseye; muestra las cámaras más recientes."
+            }
+        }
+    },
+    "ffmpeg": {
+        "retry_interval": {
+            "description": "Segundos de espera antes de intentar reconectar la transmisión de una cámara tras un fallo. El valor predeterminado es 10."
+        },
+        "path": {
+            "description": "Ruta al binario de FFmpeg que se va a utilizar o un alias de versión (\"5.0\" o \"7.0\")."
+        },
+        "output_args": {
+            "description": "Argumentos de salida predeterminados utilizados para diferentes roles de FFmpeg, tales como detección y grabación."
+        },
+        "description": "Configuración de FFmpeg, incluyendo la ruta del binario, argumentos, opciones de aceleración por hardware y argumentos de salida por rol."
+    },
+    "go2rtc": {
+        "description": "Configuración del servicio integrado de retransmisión go2rtc, utilizado para el relevo y la traducción de transmisiones en vivo."
+    },
+    "genai": {
+        "description": "Configuración para los proveedores integrados de IA generativa (GenAI) utilizados para generar descripciones de objetos y resúmenes de reseñas.",
+        "api_key": {
+            "description": "Clave de API requerida por algunos proveedores (también puede configurarse mediante variables de entorno)."
+        },
+        "base_url": {
+            "description": "URL base para proveedores autoalojados o compatibles (por ejemplo, una instancia de Ollama)."
+        },
+        "model": {
+            "description": "El modelo del proveedor que se utilizará para generar descripciones o resúmenes."
+        }
+    },
+    "face_recognition": {
+        "description": "Configuración para la detección y el reconocimiento facial en todas las cámaras; puede anularse por cámara."
+    },
+    "camera_mqtt": {
+        "required_zones": {
+            "description": "Zonas en las que debe entrar un objeto para que se publique una imagen MQTT."
         }
     }
 }

web/public/locales/es/config/groups.json

@@ -59,6 +59,15 @@
         "global": {
             "retention": "Retención global",
             "events": "Eventos globales"
+        },
+        "cameras": {
+            "events": "Evento",
+            "retention": "Retención"
+        }
+    },
+    "ffmpeg": {
+        "cameras": {
+            "cameraFfmpeg": "Argumentos de FFmpeg específicos de la cámara"
         }
     }
 }

web/public/locales/es/config/validation.json

@@ -19,7 +19,8 @@
     "ffmpeg": {
         "inputs": {
             "rolesUnique": "Cada rol solo puede asignarse a un flujo de entrada.",
-            "detectRequired": "Al menos un flujo de entrada debe tener asignado el rol 'detect'."
+            "detectRequired": "Al menos un flujo de entrada debe tener asignado el rol 'detect'.",
+            "hwaccelDetectOnly": "Solo el flujo de entrada con la función \"detect\" puede definir argumentos de aceleración por hardware."
         }
     },
     "anyOf": "Debe coincidir con al menos uno de los esquemas permitidos",

web/public/locales/es/objects.json

@@ -47,7 +47,7 @@
   "carrot": "Zanahoria",
   "hot_dog": "Perrito caliente",
   "pizza": "Pizza",
-  "donut": "Donut",
+  "donut": "Rosquilla",
   "chair": "Silla",
   "couch": "Sofá",
   "potted_plant": "Planta en maceta",

web/public/locales/es/views/classificationModel.json

@@ -12,12 +12,12 @@
   },
   "toast": {
     "success": {
-      "deletedCategory_one": "Clase Borrada",
+      "deletedCategory_one": "Se eliminó {{count}} clase",
-      "deletedCategory_many": "",
+      "deletedCategory_many": "Se eliminaron {{count}} clases",
-      "deletedCategory_other": "",
+      "deletedCategory_other": "Se eliminaron {{count}} clases",
-      "deletedImage_one": "Imágenes Borradas",
+      "deletedImage_one": "Se eliminó {{count}} imagen",
-      "deletedImage_many": "",
+      "deletedImage_many": "Se eliminaron {{count}} imágenes",
-      "deletedImage_other": "",
+      "deletedImage_other": "Se eliminaron {{count}} imágenes",
       "deletedModel_one": "Borrado con éxito {{count}} modelo",
       "deletedModel_many": "Borrados con éxito {{count}} modelos",
       "deletedModel_other": "Borrados con éxito {{count}} modelos",
@@ -68,7 +68,7 @@
   "details": {
     "scoreInfo": "La puntuación representa la confianza media de clasificación en todas las detecciones de este objeto.",
     "unknown": "Desconocido",
-    "none": "Ninguna"
+    "none": "Ninguno"
   },
   "categorizeImage": "Clasificar Imagen",
   "menu": {

web/public/locales/es/views/exports.json

@@ -22,17 +22,26 @@
     "downloadVideo": "Descargar video",
     "editName": "Editar nombre",
     "deleteExport": "Eliminar exportación",
-    "assignToCase": "Añadir al caso"
+    "assignToCase": "Añadir al caso",
+    "removeFromCase": "Remover del contenedor"
   },
   "headings": {
     "cases": "Casos",
-    "uncategorizedExports": "Exportaciones sin categorizar"
+    "uncategorizedExports": "Exportaciones sin Categorizar"
   },
   "caseDialog": {
     "title": "Añadir al caso",
     "newCaseOption": "Crear nuevo caso",
     "nameLabel": "Nombre del caso",
     "description": "Elige un caso existente o crea uno nuevo.",
-    "selectLabel": "Caso"
+    "selectLabel": "Caso",
+    "descriptionLabel": "Descripción"
+  },
+  "toolbar": {
+    "addExport": "Añadir Exportación"
+  },
+  "deleteCase": {
+    "label": "Eliminar caso",
+    "desc": "¿Estás seguro de que quieres eliminar {{caseName}}?"
   }
 }

web/public/locales/es/views/live.json

@@ -17,7 +17,7 @@
         "label": "Haz clic en el marco para centrar la cámara",
         "enable": "Habilitar clic para mover",
         "disable": "Deshabilitar clic para mover",
-        "enableWithZoom": "Activar clic para mover / arrastrar para hacer zoom"
+        "enableWithZoom": "Habilitar clic para mover / arrastrar para aumentar"
       },
       "up": {
         "label": "Mover la cámara PTZ hacia arriba"

web/public/locales/es/views/settings.json

@@ -21,7 +21,7 @@
   "menu": {
     "cameras": "Configuración de Cámara",
     "debug": "Depuración",
-    "ui": "Interfaz de usuario",
+    "ui": "Interfaz de Usuario",
     "classification": "Clasificación",
     "motionTuner": "Ajuste de movimiento",
     "masksAndZones": "Máscaras / Zonas",
@@ -35,7 +35,22 @@
     "cameraReview": "Revisar",
     "general": "General",
     "globalConfig": "Configuración Global",
-    "system": "Sistema"
+    "system": "Sistema",
+    "integrations": "Integraciones",
+    "uiSettings": "Configuración de Interfaz de Usuario",
+    "profiles": "Perfiles",
+    "globalDetect": "Detección de Objetos",
+    "globalRecording": "Grabación",
+    "globalSnapshots": "Instantáneas",
+    "globalFfmpeg": "FFmpeg",
+    "globalMotion": "Detección de Movimiento",
+    "globalObjects": "Objetos",
+    "globalReview": "Revisión",
+    "globalAudioEvents": "Eventos de Audio",
+    "globalLivePlayback": "Reproducción en Vivo",
+    "globalTimestampStyle": "Estilo de Marca de Tiempo",
+    "systemDatabase": "Base de Datos",
+    "systemAuthentication": "Autenticación"
   },
   "dialog": {
     "unsavedChanges": {
@@ -353,6 +368,9 @@
       "allObjects": "Todos los objetos",
       "toast": {
         "success": "La zona ({{zoneName}}) ha sido guardada."
+      },
+      "enabled": {
+        "description": "Indica si esta zona está activa y habilitada en la configuración. Si está deshabilitado, no puede ser habilitado por MQTT. Las zonas deshabilitadas se ignoran durante la ejecución."
       }
     },
     "toast": {
@@ -697,7 +715,7 @@
         "cleanCopySnapshots": "<code>clean_copy</code> Instantáneas"
       },
       "desc": "Enviar a Frigate+ requiere que tanto las capturas instantáneas como las capturas <code>clean_copy</code> estén habilitadas en tu configuración.",
-      "cleanCopyWarning": "Algunas cámaras tienen las instantáneas habilitadas pero tienen la copia limpia desactivada. Necesitas habilitar <code>clean_copy</code> en tu configuración de instantáneas para poder enviar imágenes de estas cámaras a Frigate+."
+      "cleanCopyWarning": "Algunas cámaras tienen las instantáneas deshabilitadas"
     },
     "modelInfo": {
       "title": "Información del modelo",
@@ -722,7 +740,8 @@
       "error": "No se pudieron guardar los cambios en la configuración: {{errorMessage}}"
     },
     "restart_required": "Es necesario reiniciar (se ha cambiado el modelo Frigate+)",
-    "unsavedChanges": "Cambios en la configuración de Frigate+ no guardados"
+    "unsavedChanges": "Cambios en la configuración de Frigate+ no guardados",
+    "description": "Frigate+ es un servicio de suscripción que proporciona acceso a funciones y capacidades adicionales para su instancia de Frigate, incluida la posibilidad de utilizar modelos de detección de objetos personalizados entrenados con sus propios datos. Puede gestionar la configuración de sus modelos de Frigate+ aquí."
   },
   "enrichments": {
     "title": "Configuración de Enriquecimientos",
@@ -1172,7 +1191,8 @@
     "backToSettings": "Volver a configuración de la cámara",
     "streams": {
       "title": "Habilitar/deshabilitar cámaras",
-      "desc": "Desactiva temporalmente una cámara hasta que Frigate se reinicie. Desactivar una cámara detiene por completo el procesamiento de las transmisiones de Frigate. La detección, la grabación y la depuración no estarán disponibles.<br /> <em>Nota: Esto no desactiva las retransmisiones de go2rtc.</em>"
+      "desc": "Desactiva temporalmente una cámara hasta que Frigate se reinicie. Desactivar una cámara detiene por completo el procesamiento de las transmisiones de Frigate. La detección, la grabación y la depuración no estarán disponibles.<br /> <em>Nota: Esto no desactiva las retransmisiones de go2rtc.</em>",
+      "enableDesc": "Deshabilita temporalmente una cámara habilitada hasta que Frigate se reinicie. Deshabilitar una cámara detiene por completo el procesamiento de las transmisiones de esa cámara por parte de Frigate. La detección, la grabación y la depuración no estarán disponibles.<br /> <em>Nota: Esto no deshabilita las retransmisiones de go2rtc.</em>"
     },
     "cameraConfig": {
       "add": "Añadir cámara",
@@ -1202,6 +1222,9 @@
       "toast": {
         "success": "Cámara {{cameraName}} guardada correctamente"
       }
+    },
+    "deleteCameraDialog": {
+      "description": "Eliminar una cámara borrará permanentemente todas las grabaciones, los objetos rastreados y la configuración de esa cámara. Es posible que sea necesario eliminar manualmente cualquier transmisión go2rtc asociada a esta cámara."
     }
   },
   "cameraReview": {
@@ -1253,12 +1276,133 @@
   "maintenance": {
     "sync": {
       "verboseDesc": "Escribe una lista completa de archivos huérfanos en el disco para su revisión.",
-      "verbose": "Detallado"
+      "verbose": "Detallado",
+      "desc": "Frigate limpiará periódicamente los archivos multimedia según un cronograma regular, de acuerdo con su configuración de retención. Es normal ver algunos archivos huérfanos mientras Frigate se ejecuta. Utilice esta función para eliminar del disco los archivos multimedia huérfanos que ya no se referencian en la base de datos.",
+      "forceDesc": "Omitir el umbral de seguridad y completar la sincronización incluso si se eliminara más del 50% de los archivos."
+    },
+    "regionGrid": {
+      "clearConfirmDesc": "No se recomienda borrar la cuadrícula de la región a menos que haya cambiado recientemente el tamaño del modelo de su detector o la posición física de su cámara y esté experimentando problemas de seguimiento de objetos. La cuadrícula se reconstruirá automáticamente con el tiempo a medida que se realice el seguimiento de los objetos. Es necesario reiniciar Frigate para que los cambios surtan efecto.",
+      "desc": "La cuadrícula de regiones es una optimización que aprende dónde suelen aparecer los objetos de diferentes tamaños en el campo de visión de cada cámara. Frigate utiliza estos datos para dimensionar de forma eficiente las regiones de detección. La cuadrícula se construye automáticamente a lo largo del tiempo a partir de los datos de los objetos rastreados."
     }
   },
   "configForm": {
     "camera": {
-      "noCameras": "No hay cámaras disponibles"
+      "noCameras": "No hay cámaras disponibles",
+      "description": "Estos ajustes se aplican únicamente a esta cámara y anulan los ajustes globales."
+    },
+    "genaiModel": {
+      "noModels": "No hay modelos disponibles"
+    },
+    "global": {
+      "description": "Estos ajustes se aplican a todas las cámaras, a menos que se anulen en los ajustes específicos de cada cámara."
+    }
+  },
+  "globalConfig": {
+    "title": "Configuración global",
+    "description": "Configura los ajustes globales que se aplican a todas las cámaras, a menos que se sobrescriban.",
+    "toast": {
+      "success": "Ajustes globales guardados con éxito",
+      "error": "Error al guardar los ajustes globales",
+      "validationError": "Error de validación"
+    }
+  },
+  "cameraConfig": {
+    "title": "Configuración de cámara",
+    "description": "Configura los ajustes de cámaras individuales. Estos ajustes sobrescriben los valores globales predeterminados.",
+    "overriddenBadge": "Sobrescrito",
+    "resetToGlobal": "Restablecer al valor global",
+    "toast": {
+      "success": "Ajustes de cámara guardados con éxito",
+      "error": "Error al guardar los ajustes de cámara"
+    }
+  },
+  "toast": {
+    "success": "Ajustes guardados con éxito",
+    "applied": "Ajustes aplicados con éxito",
+    "successRestartRequired": "Ajustes guardados con éxito. Reinicia Frigate para aplicar los cambios.",
+    "error": "Error al guardar los ajustes",
+    "validationError": "Error de validación: {{message}}",
+    "resetSuccess": "Restablecido a los valores globales predeterminados",
+    "resetError": "Error al restablecer los ajustes",
+    "saveAllSuccess_one": "Se ha guardado {{count}} sección con éxito.",
+    "saveAllSuccess_many": "Se han guardado las {{count}} secciones con éxito.",
+    "saveAllSuccess_other": "Se han guardado {{count}} secciones con éxito.",
+    "saveAllPartial_one": "Se ha guardado {{successCount}} de {{totalCount}} sección. {{failCount}} ha fallado.",
+    "saveAllPartial_many": "Se han guardado {{successCount}} de {{totalCount}} secciones. {{failCount}} han fallado.",
+    "saveAllPartial_other": "Se han guardado {{successCount}} de {{totalCount}} secciones. {{failCount}} han fallado.",
+    "saveAllFailure": "Error al guardar todas las secciones."
+  },
+  "profiles": {
+    "title": "Perfiles",
+    "activeProfile": "Perfil activo",
+    "noActiveProfile": "Sin perfil activo",
+    "active": "Activo",
+    "activated": "Perfil '{{profile}}' activado",
+    "activateFailed": "Error al establecer el perfil",
+    "deactivated": "Perfil desactivado",
+    "noProfiles": "No hay perfiles definidos.",
+    "noOverrides": "Sin sobrescripciones",
+    "cameraCount_one": "{{count}} cámara",
+    "cameraCount_many": "{{count}} de cámaras",
+    "cameraCount_other": "{{count}} cámaras",
+    "columnCamera": "Cámara",
+    "columnOverrides": "Sobrescripciones del perfil",
+    "baseConfig": "Configuración base",
+    "addProfile": "Añadir perfil",
+    "newProfile": "Nuevo perfil",
+    "profileNamePlaceholder": "ej. Armado, Fuera de casa, Modo noche",
+    "friendlyNameLabel": "Nombre del perfil",
+    "profileIdLabel": "ID del perfil",
+    "profileIdDescription": "Identificador interno utilizado en la configuración y automatizaciones",
+    "nameInvalid": "Solo se permiten letras minúsculas, números y guiones bajos",
+    "nameDuplicate": "Ya existe un perfil con este nombre",
+    "error": {
+      "mustBeAtLeastTwoCharacters": "Debe tener al menos 2 caracteres",
+      "mustNotContainPeriod": "No debe contener puntos",
+      "alreadyExists": "Ya existe un perfil con este ID"
+    },
+    "renameProfile": "Renombrar perfil",
+    "renameSuccess": "Perfil renombrado a '{{profile}}'",
+    "enabledDescription": "Los perfiles están habilitados. Cree un nuevo perfil a continuación, navegue a una sección de configuración de cámara para realizar sus cambios y guarde para que estos surtan efecto.",
+    "disabledDescription": "Los perfiles le permiten definir conjuntos con nombre de anulaciones de configuración de la cámara (por ejemplo: armado, fuera, noche) que pueden activarse bajo demanda."
+  },
+  "go2rtcStreams": {
+    "renameStreamDesc": "Introduce un nuevo nombre para esta transmisión. Cambiar el nombre de una transmisión puede provocar fallos en las cámaras u otras transmisiones que hagan referencia a ella por su nombre.",
+    "addStreamDesc": "Introduce un nombre para la nueva transmisión. Este nombre se utilizará para hacer referencia a la transmisión en la configuración de su cámara.",
+    "description": "Gestione las configuraciones de transmisión de go2rtc para la retransmisión de cámaras. Cada transmisión tiene un nombre y una o más URL de origen.",
+    "deleteStreamConfirm": "¿Está seguro de que desea eliminar la transmisión \"{{streamName}}\"? Las cámaras que hagan referencia a esta transmisión podrían dejar de funcionar."
+  },
+  "configMessages": {
+    "birdseye": {
+      "objectsModeDetectDisabled": "Birdseye está configurado en modo 'objects', pero la detección de objetos está desactivada para esta cámara. La cámara no aparecerá en Birdseye."
+    },
+    "lpr": {
+      "globalDisabled": "El reconocimiento de matrículas no está habilitado a nivel global. Habilítelo en la configuración global para que funcione el reconocimiento de matrículas a nivel de cámara."
+    },
+    "audio": {
+      "noAudioRole": "Ninguna transmisión tiene definido el rol de audio. Debe habilitar el rol de audio para que funcione la detección de audio."
+    },
+    "faceRecognition": {
+      "personNotTracked": "El reconocimiento facial requiere que se realice el seguimiento del objeto 'person'. Asegúrese de que 'person' se encuentre en la lista de seguimiento de objetos."
+    },
+    "audioTranscription": {
+      "audioDetectionDisabled": "La detección de audio no está habilitada para esta cámara. La transcripción de audio requiere que la detección de audio esté activa."
+    },
+    "snapshots": {
+      "detectDisabled": "La detección de objetos está desactivada. Las instantáneas se generan a partir de los objetos rastreados y no se crearán."
+    },
+    "detectors": {
+      "mixedTypes": "Todos los detectores deben ser del mismo tipo. Retire los detectores existentes para utilizar un tipo diferente."
+    },
+    "review": {
+      "detectDisabled": "La detección de objetos está desactivada. Los elementos de revisión requieren objetos detectados para categorizar las alertas y detecciones."
+    }
+  },
+  "resetToDefaultDescription": "Esto restablecerá todos los ajustes de esta sección a sus valores predeterminados. Esta acción no se puede deshacer.",
+  "resetToGlobalDescription": "Esto restablecerá la configuración de esta sección a los valores predeterminados globales. Esta acción no se puede deshacer.",
+  "detectionModel": {
+    "plusActive": {
+      "description": "Esta instancia está ejecutando un modelo de Frigate+. Seleccione o cambie su modelo en la configuración de Frigate+."
     }
   }
 }

web/public/locales/es/views/system.json

@@ -45,10 +45,17 @@
         "reviews": "Revisiones",
         "face_recognition": "Reconocimiento facial",
         "camera_activity": "Actividad de cámara",
-        "classification": "Clasificación"
+        "classification": "Clasificación",
+        "system": "Sistema",
+        "camera": "Cámara",
+        "all_cameras": "Todas las cámaras",
+        "cameras_count_one": "{{count}} Cámara",
+        "cameras_count_other": "{{count}} Cámaras",
+        "lpr": "Reconocimiento de matriculas"
       },
       "count_other": "{{count}} mensajes",
-      "count_one": "{{count}} mensaje"
+      "count_one": "{{count}} mensaje",
+      "empty": "No se han capturado mensaje aún"
     }
   },
   "title": "Sistema",
@@ -99,7 +106,10 @@
         "title": "Aviso de estadísticas Intel GPU",
         "message": "Estadísticas de GPU no disponibles",
         "description": "Este es un error conocido en las herramientas de informes de estadísticas de GPU de Intel (intel_gpu_top). El error se produce y muestra repetidamente un uso de GPU del 0 %, incluso cuando la aceleración de hardware y la detección de objetos se ejecutan correctamente en la (i)GPU. No se trata de un error de Frigate. Puede reiniciar el host para solucionar el problema temporalmente y confirmar que la GPU funciona correctamente. Esto no afecta al rendimiento."
-      }
+      },
+      "npuTemperature": "Temperatura NPU",
+      "gpuCompute": "Cálculo GPU / Codificación",
+      "gpuTemperature": "Temperatura GPU"
     },
     "otherProcesses": {
       "title": "Otros Procesos",
@@ -136,7 +146,11 @@
     },
     "shm": {
       "title": "Asignación de SHM (memoria compartida)",
-      "warning": "El tamaño actual de SHM de {{total}}MB es muy pequeño. Aumente al menos a {{min_shm}}MB."
+      "warning": "El tamaño actual de SHM de {{total}}MB es muy pequeño. Aumente al menos a {{min_shm}}MB.",
+      "frameLifetime": {
+        "title": "Tiempo de vida del fotograma",
+        "description": "Cada cámara tiene espacio en la memoria compartida para {{frames}} cuadros. Si la velocidad de cuadros de la cámara es alta, cada cuadro se guarda aproximadamente {{lifetime}} antes de ser sobreescrito."
+      }
     }
   },
   "cameras": {
@@ -174,7 +188,8 @@
       "cameraDetect": "{{camName}} detectar",
       "cameraFramesPerSecond": "{{camName}} cuadros por segundo",
       "cameraDetectionsPerSecond": "{{camName}} detecciones por segundo",
-      "overallSkippedDetectionsPerSecond": "detecciones omitidas por segundo totales"
+      "overallSkippedDetectionsPerSecond": "detecciones omitidas por segundo totales",
+      "cameraGpu": "{{camName}} GPU"
     },
     "toast": {
       "success": {
@@ -183,6 +198,17 @@
       "error": {
         "unableToProbeCamera": "No se pudo sondear la cámara: {{errorMessage}}"
       }
+    },
+    "connectionQuality": {
+      "excellent": "Excelente",
+      "poor": "Debil",
+      "title": "Calidad de la conexión",
+      "fps": "Cuadros por segundo",
+      "expectedFps": "Cuadros por segundo esperados",
+      "reconnectsLastHour": "Reconexiones (última hora)",
+      "unusable": "No usable",
+      "fair": "Normal",
+      "stallsLastHour": "Bloqueos (última hora)"
     }
   },
   "lastRefreshed": "Última actualización: ",
@@ -221,6 +247,7 @@
     "detectIsSlow": "{{detect}} es lento ({{speed}} ms)",
     "cameraIsOffline": "{{camera}} está desconectada",
     "detectIsVerySlow": "{{detect}} es muy lento ({{speed}} ms)",
-    "shmTooLow": "Asignación de /dev/shm ({{total}} MB) debe aumentarse al menos a {{min}} MB."
+    "shmTooLow": "Asignación de /dev/shm ({{total}} MB) debe aumentarse al menos a {{min}} MB.",
+    "debugReplayActive": "Sesión de depuración activa"
   }
 }

web/public/locales/et/audio.json

@@ -113,5 +113,165 @@
   "quack": "Prääksumine",
   "goose": "Hani",
   "honk": "Kaagatamine",
-  "wild_animals": "Metsloomad"
+  "wild_animals": "Metsloomad",
+  "roaring_cats": "Möirgavad kassid",
+  "roar": "Möirgamine",
+  "chirp": "Sirisemine",
+  "squawk": "Prääksatamine",
+  "pigeon": "Tuvi",
+  "coo": "Kudrutamine",
+  "crow": "Vares",
+  "caw": "Kraaksumine",
+  "owl": "Öökull",
+  "hoot": "Huikamine",
+  "flapping_wings": "Tiibade laperdamine",
+  "buzz": "Sumisemine",
+  "frog": "Konn",
+  "croak": "Krooksumine",
+  "snake": "Madu",
+  "rattle": "Kõristamine/lõgistamine",
+  "whale_vocalization": "Vaalaskala häälitsused",
+  "music": "Muusika",
+  "musical_instrument": "Pill",
+  "plucked_string_instrument": "Keelpill",
+  "guitar": "Kitarr",
+  "electric_guitar": "Elektrikitarr",
+  "bass_guitar": "Basskitarr",
+  "acoustic_guitar": "Akustiline kitarr",
+  "sitar": "Sitar",
+  "mandolin": "Mandoliin",
+  "banjo": "Bändžo",
+  "zither": "Kannel/tsitter",
+  "ukulele": "Ukulele",
+  "piano": "Klaver",
+  "electric_piano": "Elektriklaver",
+  "organ": "Orel",
+  "electronic_organ": "Elektriorel",
+  "hammond_organ": "Hammond-orel",
+  "synthesizer": "Süntesaator",
+  "sampler": "Sämpler",
+  "harpsichord": "Klavessiin",
+  "percussion": "Löökriistad",
+  "drum_kit": "Trummikomplekt",
+  "bass_drum": "Basstrumm",
+  "tambourine": "Tamburiin",
+  "glockenspiel": "Ksülofon",
+  "vibraphone": "Vibrafon (metalltorudega ksülofon)",
+  "marimba": "Marimbafon",
+  "tubular_bells": "Torukellad",
+  "gong": "Gong",
+  "orchestra": "Orkester",
+  "cello": "Tšello",
+  "pizzicato": "Pizzicato (poogenpilli sõrmega mängimine)",
+  "violin": "Viiul",
+  "string_section": "Keelpillid",
+  "trombone": "Tromboon",
+  "trumpet": "Trompet",
+  "french_horn": "Metsasarv",
+  "brass_instrument": "Puhkpillid",
+  "double_bass": "Kontrabass",
+  "wind_instrument": "Puhkpill",
+  "flute": "Flööt",
+  "saxophone": "Saksofon",
+  "clarinet": "Klarnet",
+  "harp": "Harf",
+  "bell": "Kellad",
+  "church_bell": "Kirikukell",
+  "jingle_bell": "Aisakell",
+  "bicycle_bell": "Rattakell",
+  "tuning_fork": "Helihark/kammertoon",
+  "bagpipes": "Torupillid",
+  "didgeridoo": "Didžeriduu",
+  "pop_music": "Popmuusika",
+  "hip_hop_music": "Hiphop muusika",
+  "rock_music": "Rokkmuusika",
+  "beatboxing": "Beatbox",
+  "heavy_metal": "Hevimuusika",
+  "punk_rock": "Punkrokk",
+  "grunge": "Grunge",
+  "progressive_rock": "Progressiivne rokk",
+  "rhythm_and_blues": "Rütmibluus",
+  "soul_music": "Soulmuusika",
+  "reggae": "Reggae",
+  "country": "Kantrimuusika",
+  "funk": "Funkmuusika",
+  "folk_music": "Rahvamuusika",
+  "middle_eastern_music": "Lähis-Ida muusika",
+  "jazz": "Džäss",
+  "disco": "Disko",
+  "classical_music": "Klassikaline muusika",
+  "opera": "Ooper",
+  "electronic_music": "Elektrooniline muusika",
+  "house_music": "House-muusika",
+  "techno": "Tekno",
+  "dubstep": "Dubstep",
+  "drum_and_bass": "Drum and Bass",
+  "electronic_dance_music": "Elektrooniline tantsumuusika",
+  "music_of_latin_america": "Ladina-Ameerika muusika",
+  "salsa_music": "Salsa",
+  "flamenco": "Flamenko",
+  "blues": "Bluus",
+  "music_for_children": "Lastemuusika",
+  "new-age_music": "New Age muusika",
+  "vocal_music": "Laulmine",
+  "a_capella": "A Capella",
+  "music_of_africa": "Aafrika muusika",
+  "afrobeat": "Afrobeat",
+  "christian_music": "Kristlik muusika",
+  "gospel_music": "Gospelmuusika",
+  "music_of_asia": "Aasia muusika",
+  "music_of_bollywood": "Bollywoodi muusika",
+  "ska": "Ska",
+  "carnatic_music": "Karnataka muusika",
+  "trance_music": "Trance muusika",
+  "ambient_music": "Ambient muusika",
+  "electronica": "Electronica",
+  "swing_music": "Svingmuusika",
+  "bluegrass": "Bluegrass",
+  "psychedelic_rock": "Psühhedeelne rokk",
+  "rock_and_roll": "Rock'n'roll",
+  "scratching": "Kriipimine/kraapimine",
+  "theremin": "Teremin",
+  "accordion": "Akordion",
+  "harmonica": "Suupill",
+  "wind_chime": "Tuulekell",
+  "chime": "Kelluke",
+  "traditional_music": "Traditsiooniline muusika",
+  "independent_music": "Sõltumatu muusika",
+  "song": "Laul",
+  "background_music": "Taustamuusika",
+  "lullaby": "Hällilaul",
+  "christmas_music": "Jõulumuusika",
+  "video_game_music": "Videomängude muusika",
+  "dance_music": "Tantsumuusika",
+  "wedding_music": "Pulmamuusika",
+  "happy_music": "Rõõmus muusika",
+  "sad_music": "Kurb muusika",
+  "tender_music": "Tundeline muusika",
+  "angry_music": "Vihane muusika",
+  "exciting_music": "Põnev muusika",
+  "scary_music": "Hirmutav muusika",
+  "wind": "Tuul",
+  "thunderstorm": "Äikesetorm",
+  "thunder": "Kõu/äike",
+  "water": "Vesi",
+  "rain": "Vihm",
+  "raindrop": "Vihmapiisk",
+  "spray": "Pritsimine",
+  "pump": "Pumpamine",
+  "stir": "Segamine/nihelemine",
+  "boiling": "Keemine",
+  "sonar": "Kajalood",
+  "arrow": "Nool",
+  "whoosh": "Vuhh/vuhisemine",
+  "thump": "Potsatus/mütsatus",
+  "thunk": "Põmakas",
+  "doorbell": "Uksekell",
+  "traffic_noise": "Liiklusmüra",
+  "rail_transport": "Raudteetransport",
+  "train_whistle": "Rongivile",
+  "sailboat": "Purjekas",
+  "soundtrack_music": "Filmimuusika",
+  "jingle": "Kõlisemine/tilisemine",
+  "theme_music": "Tunnusmuusika"
 }

web/public/locales/et/common.json

@@ -181,7 +181,8 @@
     "classification": "Klassifikatsioon",
     "chat": "Vestlus",
     "actions": "Tegevused",
-    "profiles": "Profiilid"
+    "profiles": "Profiilid",
+    "features": "Funktsionaalsused"
   },
   "unit": {
     "speed": {

web/public/locales/et/components/filter.json

@@ -4,13 +4,16 @@
     "toast": {
       "error": "Jälgitavate objektide kustutamine ei õnnestunud: {{errorMessage}}",
       "success": "Jälgitavate objektide kustutamine õnnestus."
-    }
+    },
+    "title": "Kinnita kustutamine",
+    "desc": "Nende {{objectLength}} jälgitava objekti kustutamine eemaldab tõmmise salvestuse, kõik seotud salvestatud sissekanded ja kõik seotud objekti elutsükli kirjed. Ajaloo vaates salvestatud videomaterjali nende jälgitavate objektide kohta <em>EI</em> kustutata.<br /><br/>Kas soovid kindlasti jätkata?<br/><br/>Hoia <em>Shift</em>-klahvi all, et seda teateakent tulevikus vahele jätta."
   },
   "cameras": {
     "all": {
       "title": "Kõik kaamerad",
       "short": "Kaamerad"
-    }
+    },
+    "label": "Kaamerate filter"
   },
   "labels": {
     "all": {
@@ -38,7 +41,8 @@
       "defaultView": {
         "title": "Vaikimisi vaade",
         "summary": "Kokkuvõte",
-        "unfilteredGrid": "Filtreerimata ruudustik"
+        "unfilteredGrid": "Filtreerimata ruudustik",
+        "desc": "Kui filtreid pole valitud, näita viimaste jälgitud objektide kokkuvõtet sildi kohta või näita filtreerimata ruudustikuvaadet."
       },
       "gridColumns": {
         "title": "Ruudustiku veerud",
@@ -48,16 +52,26 @@
         "options": {
           "thumbnailImage": "Pisipilt",
           "description": "Kirjeldus"
-        }
+        },
+        "label": "Otsinguallikas",
+        "desc": "Vali, kas soovid otsida sinu jälgitavate objektide pisipilte või kirjeldusi."
+      }
+    },
+    "date": {
+      "selectDateBy": {
+        "label": "Vali kuupäev, mille alusel tahad filtreerida"
       }
     }
   },
   "logSettings": {
     "loading": {
-      "title": "Laadin"
+      "title": "Laadin",
+      "desc": "Kui logipaneeli vaade on keritud lõpuni, siis kuvatakse lisanduvad logikirjed automaatselt kohe."
     },
     "disableLogStreaming": "Keela logi voogedastus",
-    "allLogs": "Kõik logid"
+    "allLogs": "Kõik logid",
+    "label": "Logimistase filtri jaoks",
+    "filterBySeverity": "Kriitilisus filtri jaoks"
   },
   "classes": {
     "label": "Klassid",
@@ -83,6 +97,44 @@
   "estimatedSpeed": "Hinnanguline kiirus: ({{unit}})",
   "features": {
     "label": "Omadused",
-    "hasSnapshot": "Leidub hetkvõte"
+    "hasSnapshot": "Leidub hetkvõte",
+    "hasVideoClip": "Videoklipp on olemas",
+    "submittedToFrigatePlus": {
+      "label": "Saadetud teenusesse Frigate+",
+      "tips": "Sa pead filtreerima jälgitavaid objekte, millel on tõmmis.<br /><br />Kui jälgitaval objektil pole tõmmist, siis teda Frigate+ teenusesse saata ei saa."
+    }
+  },
+  "attributes": {
+    "label": "Klassifitseerimisatribuudid",
+    "all": "Kõik atribuudid"
+  },
+  "sort": {
+    "label": "Järjestus",
+    "dateAsc": "Kuupäev (kasvavalt)",
+    "dateDesc": "Kuupäev (kahanevalt)",
+    "scoreAsc": "Objekti punktiskoor (kasvavalt)",
+    "scoreDesc": "Objekti punktiskoor (kahanevalt)",
+    "speedAsc": "Hinnanguline kiirus (kasvavalt)",
+    "speedDesc": "Hinnanguline kiirus (kahanevalt)",
+    "relevance": "Teemakohasus"
+  },
+  "review": {
+    "showReviewed": "Näita ülevaadatuid"
+  },
+  "motion": {
+    "showMotionOnly": "Näita vaid liikumisega klippe"
+  },
+  "zoneMask": {
+    "filterBy": "Tsoonimask filtri jaoks"
+  },
+  "recognizedLicensePlates": {
+    "title": "Tuvastatud sõiduki numbrimärgid",
+    "loadFailed": "Tuvastatud sõiduki numbrimärkide laadimine ei õnnestunud.",
+    "loading": "Laadin tuvastatud sõiduki numbrimärke…",
+    "placeholder": "Sõidukite numbrimärkide otsimiseks kirjuta midagi…",
+    "noLicensePlatesFound": "Sõidukite numbrimärke ei leidu.",
+    "selectPlatesFromList": "Vali loendist üks või enam sõiduki numbrimärki.",
+    "selectAll": "Vali kõik",
+    "clearAll": "Eemalda kõik"
   }
 }

web/public/locales/et/components/player.json

@@ -4,7 +4,8 @@
   "noPreviewFoundFor": "{{cameraName}} kaamera eelvaadet ei leidu",
   "submitFrigatePlus": {
     "submit": "Saada",
-    "title": "Kas saadad selle kaadri Frigate+ teenusesse?"
+    "title": "Kas saadad selle kaadri Frigate+ teenusesse?",
+    "previewError": "Hetktõmmise eelvaate laadimine ei õnnestu. Salvestus ei pruugi olla hetkel saadaval."
   },
   "cameraDisabled": "Kaamera on kasutuselt eemaldatud",
   "stats": {

web/public/locales/et/config/cameras.json

@@ -2,5 +2,21 @@
     "name": {
         "label": "Kaamera nimi",
         "description": "Kaamera nimi on nõutav"
+    },
+    "friendly_name": {
+        "label": "Sõbralik nimi",
+        "description": "Frigate UI-s kasutatud kaamerasõbralik nimi"
+    },
+    "enabled": {
+        "label": "Kasutusel",
+        "description": "Kasutusel"
+    },
+    "audio": {
+        "label": "Helisündmused"
+    },
+    "birdseye": {
+        "mode": {
+            "label": "Jälgimisrežiim"
+        }
     }
 }

web/public/locales/et/config/global.json

@@ -1 +1,10 @@
-{}
+{
+    "audio": {
+        "label": "Helisündmused"
+    },
+    "birdseye": {
+        "mode": {
+            "label": "Jälgimisrežiim"
+        }
+    }
+}

web/public/locales/et/config/groups.json

@@ -1 +1,73 @@
-{}
+{
+    "audio": {
+        "global": {
+            "detection": "Üldine tuvastamine",
+            "sensitivity": "Üldine tundlikkus"
+        },
+        "cameras": {
+            "detection": "Tuvastamine",
+            "sensitivity": "Tundlikkus"
+        }
+    },
+    "motion": {
+        "global": {
+            "sensitivity": "Üldine tundlikkus",
+            "algorithm": "Üldine algoritm"
+        },
+        "cameras": {
+            "sensitivity": "Tundlikkus",
+            "algorithm": "Algoritm"
+        }
+    },
+    "snapshots": {
+        "global": {
+            "display": "Üldine vaade"
+        },
+        "cameras": {
+            "display": "Vaade"
+        }
+    },
+    "timestamp_style": {
+        "global": {
+            "appearance": "Üldine välimus"
+        },
+        "cameras": {
+            "appearance": "Välimus"
+        }
+    },
+    "detect": {
+        "global": {
+            "resolution": "Üldine eraldusvõime",
+            "tracking": "Üldine jälgimine"
+        },
+        "cameras": {
+            "resolution": "Eraldusvõime",
+            "tracking": "Jälgimine"
+        }
+    },
+    "objects": {
+        "global": {
+            "filtering": "Üldine filtreerimine",
+            "tracking": "Üldine jälgimine"
+        },
+        "cameras": {
+            "filtering": "Filtreerimine",
+            "tracking": "Jälgimine"
+        }
+    },
+    "record": {
+        "global": {
+            "retention": "Üldine säilitamine",
+            "events": "Üldised sündmused"
+        },
+        "cameras": {
+            "retention": "Säilitamine",
+            "events": "Sündmused"
+        }
+    },
+    "ffmpeg": {
+        "cameras": {
+            "cameraFfmpeg": "Kaamerakohased FFmpegi argumendid"
+        }
+    }
+}

web/public/locales/et/config/validation.json

@@ -1 +1,32 @@
-{}
+{
+    "minimum": "Peab olema vähemalt {{limit}}",
+    "maximum": "Võib olla kuni {{limit}}",
+    "exclusiveMinimum": "Peab olema suurem, kui {{limit}}",
+    "exclusiveMaximum": "Peab olema väiksem, kui {{limit}}",
+    "minLength": "Peab olema vähemalt {{limit}} tähemärk(i) pikk",
+    "maxLength": "Võib olla kuni {{limit}} tähemärk(i) pikk",
+    "minItems": "Peab sisaldama vähemalt {{limit}} objekti",
+    "maxItems": "Võib sisaldada kuni {{limit}} objekti",
+    "pattern": "Vigane vorming",
+    "required": "See väli on kohustuslik",
+    "type": "Vigane väärtuse tüüp",
+    "enum": "Peab olema üks lubatud väärtustest",
+    "const": "Väärtus ei vasta eeldatud konstandile",
+    "uniqueItems": "Kõik väärtused peavad olema unikaalsed",
+    "format": "Vigane vorming",
+    "additionalProperties": "Tundmatu omadus pole lubatud",
+    "oneOf": "Peab vastama täpselt ühele lubatud skeemile",
+    "anyOf": "Peab vastama vähemalt ühele lubatud skeemile",
+    "proxy": {
+        "header_map": {
+            "roleHeaderRequired": "Kui rollide vastendused on seadistatud, siis rollide päis on nõutav."
+        }
+    },
+    "ffmpeg": {
+        "inputs": {
+            "rolesUnique": "Iga rolli saad määrata ühele sisendvoole.",
+            "detectRequired": "„Tuvasta“ rollile pead määrama vähemalt ühe sisendvoo.",
+            "hwaccelDetectOnly": "Vaid „Tuvasta“ rolliga sisendvoog võib määratleda raudvaralise kiirenduse argumente."
+        }
+    }
+}

web/public/locales/et/views/events.json

@@ -34,7 +34,9 @@
   "normalActivity": "Tavaline",
   "needsReview": "Vajab ülevaatamist",
   "securityConcern": "Võib olla turvaprobleem",
-  "timeline": "Ajajoon",
+  "timeline": {
+    "label": "Ajajoon"
+  },
   "timeline.aria": "Vali ajajoon",
   "zoomIn": "Suumi sisse",
   "zoomOut": "Suumi välja",
@@ -53,7 +55,9 @@
   },
   "documentTitle": "Ülevaatamine - Frigate",
   "recordings": {
-    "documentTitle": "Salvestised - Frigate"
+    "documentTitle": "Salvestised - Frigate",
+    "invalidSharedLink": "Töötlemisvea tõttu ei õnnestu avada ajatempliga salvestuse linki.",
+    "invalidSharedCamera": "Tundmatu või volituseta kaamera tõttu ei õnnestu avada ajatempliga salvestuse linki."
   },
   "calendarFilter": {
     "last24Hours": "Viimased 24 tundi"
@@ -61,5 +65,28 @@
   "objectTrack": {
     "clickToSeek": "Klõpsa siia ajapunkti kerimiseks",
     "trackedPoint": "Jälgitav punkt"
+  },
+  "motionSearch": {
+    "menuItem": "Liikumise otsing",
+    "openMenu": "Kaamera valikud"
+  },
+  "motionPreviews": {
+    "menuItem": "Vaata liikumiste eelvaateid",
+    "title": "Liikumiste eelvaated: {{camera}}",
+    "mobileSettingsTitle": "Liikumiste eelvaadete seadistused",
+    "mobileSettingsDesc": "Kohenda taasesituse kiirust ja heledust ning vali kuupäev, et vaadata läbi ainult liikumist kajastavaid klipid.",
+    "dim": "Hämarus",
+    "dimAria": "Muuda hämarust",
+    "dimDesc": "Kohenda hämarust parandamaks liikumisala nähtavust.",
+    "speed": "Kiirus",
+    "speedAria": "Vali eelvaate taasesituse kiirus",
+    "speedDesc": "Määratle kiirus, millega eelvaate klippe näidatakse.",
+    "back": "Tagasi",
+    "empty": "Ühtegi eelvaadet pole saadaval",
+    "noPreview": "Eelvaade pole saadaval",
+    "seekAria": "Keri „{{camera}}“ kaamera vaade ajatempli juurde: {{time}}",
+    "filter": "Filtreeri",
+    "filterDesc": "Näitamaks ainult liikumisega klippe antud aladel, vali soovitud piirkonnad.",
+    "filterClear": "Tühjenda"
   }
 }

web/public/locales/et/views/explore.json

@@ -36,7 +36,10 @@
         "ratio": "Suhtarv",
         "area": "Ala",
         "score": "Punktiskoor"
-      }
+      },
+      "external": "{{label}} on tuvastatud",
+      "heard": "{{label}} on kuuldud",
+      "gone": "{{label}} on jäänud"
     },
     "title": "Jälgimise üksikasjad",
     "noImageFound": "Selle ajatempli kohta ei leidu pilti.",
@@ -44,7 +47,8 @@
     "carousel": {
       "previous": "Eelmine slaid",
       "next": "Järgmine slaid"
-    }
+    },
+    "count": "{{first}} / {{second}}"
   },
   "documentTitle": "Avasta - Frigate",
   "generativeAI": "Generatiivne tehisaru",

web/public/locales/et/views/faceLibrary.json

@@ -34,6 +34,11 @@
   },
   "details": {
     "timestamp": "Ajatampel",
-    "unknown": "Pole teada"
+    "unknown": "Pole teada",
+    "scoreInfo": "Skoor on kõigi nägude hindete kaalutud keskmine, kus kaalukoefitsiendiks on iga pildi näo suurus."
+  },
+  "uploadFaceImage": {
+    "title": "Laadi näopilt üles",
+    "desc": "Laadi üles pilt, et otsida sellelt nägusid ja lisada see {{pageToggle}}'i jaoks"
   }
 }

web/public/locales/et/views/live.json

@@ -14,7 +14,9 @@
     "autotracking": "Automaatne jälgimine",
     "recording": "Salvestus"
   },
-  "documentTitle": "Otseülekanne - Frigate",
+  "documentTitle": {
+    "default": "Frigate reaalajas"
+  },
   "documentTitle.withCamera": "{{camera}} - Otseülekanne - Frigate",
   "lowBandwidthMode": "Väikese ribalaiusega režiim",
   "twoWayTalk": {
@@ -30,7 +32,8 @@
       "clickMove": {
         "label": "Kaamerapildi joondamiseks keskele klõpsa kaadris",
         "enable": "Kasuta klõpsamisega teisaldamist",
-        "disable": "Ära kasuta klõpsamisega teisaldamist"
+        "disable": "Ära kasuta klõpsamisega teisaldamist",
+        "enableWithZoom": "Luba liigutamine klõpsuga / suumimine lohistamisega"
       },
       "left": {
         "label": "Pööra liigutatavat kaamerat vasakule"
@@ -100,11 +103,18 @@
     },
     "audio": {
       "available": "Selles voogedastuses on heliriba saadaval",
-      "unavailable": "Selles voogedastuses pole heliriba saadaval"
+      "unavailable": "Selles voogedastuses pole heliriba saadaval",
+      "tips": {
+        "title": "Heli peab tulema sinu kaamerast ja selle voogedastuse jaoks peab see go2rtc-s olema seadistatud."
+      }
     },
     "title": "Voogedastus",
     "lowBandwidth": {
-      "resetStream": "Lähtesta voogedastus"
+      "resetStream": "Lähtesta voogedastus",
+      "tips": "Reaalaja pilt on puhverdamise või voogedastuse vigade tõttu madala ribalaiusega režiimis."
+    },
+    "debug": {
+      "picker": "Voogedastuse osa valik pole silumisrežiimis saadaval. Silumisvaade kasutab alati voogedastust, millele on määratud tuvastamisroll."
     }
   },
   "notifications": "Teavitused",
@@ -137,7 +147,15 @@
     "showStats": {
       "label": "Näita statistikat",
       "desc": "Selle eelistuse puhul näidatakse voogedastuse statistikat kaamerapildi peal."
-    }
+    },
+    "tips": "Laadi alla hetktõmmis või käivita käsitsi sündmus vastavalt selle kaamera salvestiste säilitamise seadistustele.",
+    "start": "Alusta tellimuspõhist salvestamist",
+    "started": "Alustasin käsitsi tellitavat salvestamist.",
+    "failedToStart": "Käsitsi tellitava salvestamise alustamine ei õnnestunud.",
+    "recordDisabledTips": "Kuna selle kaamera seadistustes on salvestamine keelatud või piiratud, siis salvestatakse ainult pilt.",
+    "end": "Lõpeta tellimuspõhine salvestamine",
+    "ended": "Lõpetasin käsitsi tellitava salvestamise.",
+    "failedToEnd": "Käsitsi tellitava salvestamise lõpetamine ei õnnestunud."
   },
   "noCameras": {
     "buttonText": "Lisa kaamera",
@@ -174,5 +192,8 @@
   },
   "history": {
     "label": "Näita varasemat sisu"
+  },
+  "suspend": {
+    "forTime": "Peatamise aeg: "
   }
 }

web/public/locales/et/views/search.json

@@ -9,7 +9,8 @@
     "clear": "Tühjenda otsing",
     "save": "Salvesta otsing",
     "delete": "Kustuta salvestatud otsing",
-    "filterInformation": "Filtri teave"
+    "filterInformation": "Filtri teave",
+    "filterActive": "Filtreid valituna"
   },
   "filter": {
     "label": {
@@ -17,7 +18,23 @@
       "cameras": "Kaamerad",
       "labels": "Sildid",
       "zones": "Tsoonid",
-      "sub_labels": "Alamsildid"
+      "sub_labels": "Alamsildid",
+      "attributes": "Omadused",
+      "search_type": "Otsingutüüp",
+      "time_range": "Ajavahemik",
+      "before": "Enne",
+      "after": "Pärast"
+    },
+    "searchType": {
+      "thumbnail": "Pisipilt",
+      "description": "Kirjeldus"
+    },
+    "toast": {
+      "error": {
+        "beforeDateBeLaterAfter": "„Enne“ kuupäev peab olema varasem, kui „Pärast“ kuupäev.",
+        "afterDatebeEarlierBefore": "„Pärast“ kuupäev peab olema hilisem, kui „Enne“ kuupäev."
+      }
     }
-  }
+  },
+  "trackedObjectId": "Jälgitava objekti tunnus"
 }

web/public/locales/fi/common.json

@@ -42,7 +42,8 @@
     "second_other": "{{time}}sekunttia",
     "formattedTimestampHourMinute": {
       "24hour": "HH:mm"
-    }
+    },
+    "never": "Ei koskaan"
   },
   "pagination": {
     "next": {

web/public/locales/fi/components/auth.json

@@ -10,6 +10,7 @@
       "loginFailed": "Kirjautuminen epäonnistui",
       "unknownError": "Tuntematon virhe. Tarkista logit.",
       "webUnknownError": "Tuntematon virhe. Tarkista konsolilogi."
-    }
+    },
+    "firstTimeLogin": "Ensimmäistä kertaa kirjautumassa sisään? Tunnukset löytyvät Frigaten lokista."
   }
 }

web/public/locales/fi/components/dialog.json

@@ -6,7 +6,8 @@
       "title": "Fregatti käynnistyy uudelleen",
       "content": "Tämä sivu latautuu uudelleen {{countdown}} sekunnin kuluttua.",
       "button": "Pakota uudelleenlataus nyt"
-    }
+    },
+    "description": "Tämä sammuttaa Frigaten lyhyeksi aikaa uudelleenkäynnistyksen ajaksi."
   },
   "explore": {
     "plus": {

web/public/locales/fi/components/player.json

@@ -4,7 +4,8 @@
   "noRecordingsFoundForThisTime": "Ei tallenteita valitulta ajalta",
   "submitFrigatePlus": {
     "title": "Lähetä tämä kuva Frigate+:aan?",
-    "submit": "Lähetä"
+    "submit": "Lähetä",
+    "previewError": "Pysäytyskuvan esikatselua ei voi ladata. Tallenne ei ole ehkä saatavissa tällä hetkellä."
   },
   "livePlayerRequiredIOSVersion": "iOS 17.1 tai uudempi vaaditaan tälle suoratoistotyypille.",
   "streamOffline": {

web/public/locales/fi/config/cameras.json

@@ -1 +1,22 @@
-{}
+{
+    "label": "Kamerakonfiguraatio",
+    "name": {
+        "label": "Kameran nimi",
+        "description": "Kameran nimi vaaditaan"
+    },
+    "friendly_name": {
+        "label": "Kutsumanimi",
+        "description": "Kameran kutsumanimeä käytetään Frigaten käyttöliittymässä"
+    },
+    "enabled": {
+        "description": "Käytössä"
+    },
+    "audio": {
+        "label": "Ääni tapahtumat",
+        "description": "Äänipohjaisen havaitsemisen asetukset tälle kameralle.",
+        "enabled": {
+            "label": "Ota ääni havainnointi käyttöön",
+            "description": "Ota tai poista käytöstä ääni tapahtuman havaiseminen tälle kameralle."
+        }
+    }
+}

web/public/locales/fi/config/global.json

@@ -1 +1,21 @@
-{}
+{
+    "version": {
+        "label": "Nykyinen konfigurointiversio"
+    },
+    "safe_mode": {
+        "label": "Vikasietotila",
+        "description": "Kun käytössä, käynnistä Frigate vikasietotilassa rajoitetuilla ominaisuuksilla vianselvitystä varten."
+    },
+    "logger": {
+        "label": "Lokitus",
+        "default": {
+            "label": "Lokituksen taso"
+        }
+    },
+    "audio": {
+        "label": "Ääni tapahtumat",
+        "enabled": {
+            "label": "Ota ääni havainnointi käyttöön"
+        }
+    }
+}

web/public/locales/fi/config/groups.json

@@ -1 +1,30 @@
-{}
+{
+    "audio": {
+        "global": {
+            "detection": "Globaali tunnistus",
+            "sensitivity": "Globaali herkkyys"
+        },
+        "cameras": {
+            "detection": "Havaitseminen",
+            "sensitivity": "Herkkyys"
+        }
+    },
+    "timestamp_style": {
+        "global": {
+            "appearance": "Globaali vaikutelma"
+        },
+        "cameras": {
+            "appearance": "Vaikutelma"
+        }
+    },
+    "motion": {
+        "global": {
+            "sensitivity": "Globaali herkkyys",
+            "algorithm": "Globaali algoritmi"
+        },
+        "cameras": {
+            "sensitivity": "Herkkyys",
+            "algorithm": "Algoritmi"
+        }
+    }
+}

web/public/locales/fi/config/validation.json

@@ -1 +1,13 @@
-{}
+{
+    "minimum": "Täytyy olla vähintään {{limit}}",
+    "maximum": "Täytyy olla korkeitaan {{limit}}",
+    "exclusiveMinimum": "Täytyy olla suurempi kuin {{limit}}",
+    "exclusiveMaximum": "Täytyy olla vähemmän kuin {{limit}}",
+    "minLength": "Täytyy olla vähintään {{limit}} merkkiä",
+    "maxLength": "Täytyy olla enintään {{limit}} merkkiä",
+    "minItems": "Täytyy olla vähintään {{limit}} kappaletta",
+    "maxItems": "Täytyy olla enintään {{limit}} kappaletta",
+    "pattern": "Väärä formaatti",
+    "required": "Tämä kenttä on pakollinen",
+    "type": "Väärä arvon tyyppi"
+}

web/public/locales/fi/views/classificationModel.json

@@ -2,10 +2,16 @@
   "documentTitle": "Luokittelumallit - Frigate",
   "details": {
     "scoreInfo": "Pistemäärä edustaa tämän objektin kaikkien havaintojen keskimääräistä luokitteluvarmuutta.",
-    "none": "Ei mitään"
+    "none": "Ei mitään",
+    "unknown": "Tuntematon"
   },
   "button": {
     "deleteImages": "Poista kuvat",
-    "trainModel": "Kouluta malli"
+    "trainModel": "Kouluta malli",
+    "deleteClassificationAttempts": "Poista luokitellut kuvat",
+    "deleteCategory": "Poista luokka",
+    "addClassification": "Lisää luokitus",
+    "deleteModels": "Poista mallit",
+    "editModel": "Muokkaa mallia"
   }
 }

web/public/locales/fi/views/events.json

@@ -3,7 +3,10 @@
   "empty": {
     "detection": "Ei havaintoja tarkastettavaksi",
     "motion": "Ei liiketietoja",
-    "alert": "Ei hälyytyksiä tarkastettavaksi"
+    "alert": "Ei hälyytyksiä tarkastettavaksi",
+    "recordingsDisabled": {
+      "title": "Tallenteet täytyy ottaa käyttöön"
+    }
   },
   "detections": "Havainnot",
   "motion": {
@@ -11,7 +14,9 @@
     "only": "Vain liike"
   },
   "allCameras": "Kaikki kamerat",
-  "timeline": "Aikajana",
+  "timeline": {
+    "label": "Aikajana"
+  },
   "timeline.aria": "Valitse aikajana",
   "events": {
     "label": "Tapahtumat",

web/public/locales/fi/views/exports.json

@@ -8,13 +8,21 @@
     }
   },
   "noExports": "Ei vietyjä kohteita",
-  "deleteExport": "Poista viety kohde",
+  "deleteExport": {
+    "label": "Poista vienti"
+  },
   "editExport": {
     "title": "Nimeä uudelleen",
     "desc": "Anna uusi nimi viedylle kohteelle.",
     "saveExport": "Tallenna vienti"
   },
   "tooltip": {
-    "editName": "Muokkaa nimeä"
+    "editName": "Muokkaa nimeä",
+    "shareExport": "Jaa vienti",
+    "downloadVideo": "Lataa video"
+  },
+  "headings": {
+    "cases": "Tapaukset",
+    "uncategorizedExports": "Kategorisoimattomat viennit"
   }
 }

web/public/locales/fi/views/faceLibrary.json

@@ -2,7 +2,8 @@
   "description": {
     "addFace": "Opastus: Uuden kokoelman lisääminen Kasvokirjastoon.",
     "invalidName": "Virheellinen nimi. Nimi voi sisältää vain merkkejä, numeroita, välejä, heittomerkkejä, alaviivoja ja väliviivoja.",
-    "placeholder": "Anna nimi kokoelmalle"
+    "placeholder": "Anna nimi kokoelmalle",
+    "nameCannotContainHash": "Nimi ei voi sisältää \"#\"."
   },
   "uploadFaceImage": {
     "desc": "Lähetä kuva kasvojen tunnistukseen ja lisää se sivulle {{pageToggle}}",

web/public/locales/fi/views/live.json

@@ -1,5 +1,7 @@
 {
-  "documentTitle": "Suora - Frigate",
+  "documentTitle": {
+    "default": "Suora - Frigate"
+  },
   "documentTitle.withCamera": "{{camera}} - Suora - Frigate",
   "lowBandwidthMode": "Pienen kaistanleveyden tila",
   "twoWayTalk": {

web/public/locales/fi/views/settings.json

@@ -11,7 +11,9 @@
     "authentication": "Autentikointiuasetukset - Frigate",
     "notifications": "Ilmoitusasetukset - Frigate",
     "enrichments": "Laajennusasetukset – Frigate",
-    "cameraManagement": "Hallitse Kameroita - Frigate"
+    "cameraManagement": "Hallitse Kameroita - Frigate",
+    "globalConfig": "Globaali konfiguraatio - Frigate",
+    "cameraConfig": "Kamera konfiguraatio - Frigate"
   },
   "menu": {
     "ui": "Käyttöliittymä",

web/public/locales/fi/views/system.json

@@ -20,6 +20,10 @@
         "fetchingLogsFailed": "Virhe noudettaessa lokeja: {{errorMessage}}",
         "whileStreamingLogs": "Virhe toistettaessa lokeja: {{errorMessage}}"
       }
+    },
+    "websocket": {
+      "label": "Viestit",
+      "pause": "Pysäytä"
     }
   },
   "documentTitle": {
@@ -30,7 +34,8 @@
     "logs": {
       "frigate": "Frigaten lokit - Frigate",
       "go2rtc": "Go2RTC lokit - Frigate",
-      "nginx": "Nginx lokit - Frigate"
+      "nginx": "Nginx lokit - Frigate",
+      "websocket": "Viestilokit - Frigate"
     }
   },
   "title": "Järjestelmä",

web/public/locales/fr/components/player.json

@@ -4,7 +4,8 @@
   "noPreviewFound": "Aucun aperçu trouvé",
   "submitFrigatePlus": {
     "title": "Soumettre cette image à Frigate+ ?",
-    "submit": "Soumettre"
+    "submit": "Soumettre",
+    "previewError": "Impossible de télécharger le snapshot. L'enregistrement ne pas disponible sur cette période."
   },
   "streamOffline": {
     "title": "Flux hors ligne",

web/public/locales/fr/config/global.json

@@ -77,5 +77,15 @@
         "path": {
             "label": "Chemin vers la base de donnée"
         }
+    },
+    "genai": {
+        "provider": {
+            "label": "Fournisseur"
+        }
+    },
+    "birdseye": {
+        "quality": {
+            "label": "Qualité d'encodage"
+        }
     }
 }

web/public/locales/fr/views/exports.json

@@ -35,5 +35,10 @@
     "newCaseOption": "Créer un nouveau dossier",
     "nameLabel": "Nom du dossier",
     "descriptionLabel": "Description"
+  },
+  "deleteCase": {
+    "desc": "Êtes-vous sûr de vouloir supprimer {{caseName}}?",
+    "descKeepExports": "Les exports seront disponibles comme exports non catégorisés.",
+    "deleteExports": "Supprimer aussi les exports"
   }
 }

web/public/locales/fr/views/settings.json

@@ -89,7 +89,8 @@
     "cameraMqtt": "MQTT de la caméra",
     "maintenance": "Maintenance",
     "uiSettings": "Paramètres IU",
-    "profiles": "Profils"
+    "profiles": "Profils",
+    "systemGo2rtcStreams": "Streams go2rtc"
   },
   "dialog": {
     "unsavedChanges": {
@@ -448,6 +449,17 @@
         "error": {
           "mustBeGreaterOrEqualTo": "Le seuil de vitesse doit être supérieur ou égal à 0.1."
         }
+      },
+      "id": {
+        "error": {
+          "mustNotBeEmpty": "L'ID ne doit pas être vide.",
+          "alreadyExists": "Un masque avec cet ID existe déjà pour cette caméra."
+        }
+      },
+      "name": {
+        "error": {
+          "mustNotBeEmpty": "Le nom ne doit pas être vide."
+        }
       }
     },
     "zones": {
@@ -572,7 +584,11 @@
     },
     "restart_required": "Redémarrage requis (masques/zones changés)",
     "objectMaskLabel": "Masque d'objet {{number}}",
-    "motionMaskLabel": "Masque de mouvement {{number}}"
+    "motionMaskLabel": "Masque de mouvement {{number}}",
+    "disabledInConfig": "Cet objet est désactivé dans le fichier de configuration",
+    "addDisabledProfile": "Ajouter dans la configuration de base d’abord puis remplacez le dans le profil",
+    "profileBase": "(base)",
+    "profileOverride": "(remplacer)"
   },
   "motionDetectionTuner": {
     "title": "Réglage de la détection de mouvement",
@@ -1308,7 +1324,11 @@
     "backToSettings": "Retour aux paramètres de la caméra",
     "streams": {
       "title": "Activer / désactiver les caméras",
-      "desc": "Désactive temporairement une caméra jusqu'au redémarrage de Frigate. La désactivation d'une caméra interrompt complètement le traitement des flux de la caméra par Frigate. La détection, l'enregistrement et le débogage deviennent alors indisponibles.<br /><em>Remarque : cela n'affecte pas les rediffusions des flux go2rtc.</em>"
+      "desc": "Désactive temporairement une caméra jusqu'au redémarrage de Frigate. La désactivation d'une caméra interrompt complètement le traitement des flux de la caméra par Frigate. La détection, l'enregistrement et le débogage deviennent alors indisponibles.<br /><em>Remarque : cela n'affecte pas les rediffusions des flux go2rtc.</em>",
+      "enableLabel": "Caméras activées",
+      "disableLabel": "Caméra désactivées",
+      "disableDesc": "Activer une caméra qui n'est pas visible dans l'interface et désactivée dans la configuration. Un redémarrage de Frigate est nécessaire après l'activation.",
+      "enableSuccess": "Activer {{cameraName}} dans la configuration. Redémarrer Frigate pour appliquer les changements."
     },
     "cameraConfig": {
       "add": "Ajouter une caméra",
@@ -1338,6 +1358,25 @@
       "toast": {
         "success": "La caméra {{cameraName}} a été enregistrée avec succès"
       }
+    },
+    "deleteCamera": "Supprimer la caméra",
+    "deleteCameraDialog": {
+      "title": "Supprimer la caméra",
+      "description": "Supprimer la caméra va supprimer de façon permanente les enregistrements, les objets suivis, et la configuration de la caméra. Tous les streams go2rtc associés à la caméra devront être supprimés manuellement.",
+      "selectPlaceholder": "Choisir une caméra...",
+      "confirmTitle": "Êtes-vous sûr?",
+      "confirmWarning": "Supprimer <strong>\n{{cameraName}}\n</strong> ne peut être annulé.",
+      "deleteExports": "Supprimer aussi les exports de cette caméra",
+      "confirmButton": "Suppression permanente",
+      "success": "Caméra {{cameraName}} supprimée avec succès",
+      "error": "Impossible de supprimer la caméra {{cameraName}}"
+    },
+    "profiles": {
+      "selectLabel": "Choisir un profil",
+      "description": "Configurer quelles caméras sont activées ou désactivées quand un profil est activé. Les caméras activées avec \"Inherit\" conservent leur statut de base.",
+      "inherit": "Hériter",
+      "enabled": "Activé",
+      "disabled": "Désactivé"
     }
   },
   "cameraReview": {
@@ -1392,6 +1431,9 @@
     "value": {
       "label": "Nouvelle valeur",
       "reset": "Réinitialiser"
+    },
+    "profile": {
+      "label": "Profil"
     }
   },
   "button": {

web/public/locales/hu/common.json

@@ -178,7 +178,8 @@
     "configuration": "Konfiguráció",
     "systemLogs": "Rendszer naplók",
     "settings": "Beállítások",
-    "classification": "Osztályozás"
+    "classification": "Osztályozás",
+    "profiles": "Profilok"
   },
   "role": {
     "viewer": "Néző",

web/public/locales/hu/components/player.json

@@ -3,7 +3,8 @@
   "noPreviewFound": "Nincs elérhető előkép",
   "submitFrigatePlus": {
     "title": "Elküldi ezt a képet a Frigate+-nak?",
-    "submit": "Küldés"
+    "submit": "Küldés",
+    "previewError": "Nem sikerült betölteni a pillanatkép előnézetét. Előfordulhat, hogy a felvétel jelenleg nem elérhető."
   },
   "noPreviewFoundFor": "Nem található előnézet {{cameraName}}-hoz/-hez/-höz",
   "livePlayerRequiredIOSVersion": "iOS 17.1 vagy újabb szükséges ehhez az élő adás típushoz.",

web/public/locales/hu/config/cameras.json

@@ -39,6 +39,41 @@
         "description": "A Frigate felhasználói felületén használt, könnyen megjegyezhető kamera név"
     },
     "enabled": {
-        "label": "Engedélyezve"
+        "label": "Engedélyezve",
+        "description": "Engedélyezve"
+    },
+    "audio": {
+        "label": "Hangesemények",
+        "description": "Hangalapú eseményérzékelés beállításai ennél a kameránál.",
+        "enabled": {
+            "label": "Hangalapú eseményérzékelés engedélyezése",
+            "description": "A hangalapú eseményérzékelés engedélyezése vagy letiltása ennél a kameránál."
+        },
+        "max_not_heard": {
+            "description": "Ennyi másodperc után fejeződik be a hangesemény, ha a beállított hangtípus nem észlelhető.",
+            "label": "Időtúllépés befejezése"
+        },
+        "min_volume": {
+            "label": "Minimális hangerő",
+            "description": "Minimum RMS hangerő a hangérzékelés futtatásához; az alacsonyabb értékek növelik az érzékenységet (pl: 200 magas, 500 közepes, 1000 alacsony érzékenységet jelent)."
+        },
+        "listen": {
+            "label": "Hallgatási típúsok",
+            "description": "Lista a hangalapú eseményekről amit érzékelni szeretnél (angolul) (például: bark, fire_alarm, scream, speech, yell)."
+        },
+        "filters": {
+            "label": "Audio szűrők (filters)",
+            "description": "Hangtípusonkénti szűrőbeállítások (filter), mint például a téves találatok számát mérsékelő konfidencia-küszöbök."
+        },
+        "enabled_in_config": {
+            "label": "Eredeti audio állapot"
+        }
+    },
+    "audio_transcription": {
+        "label": "Hang Feliratozás",
+        "description": "„Beállítások élő hang és beszéd automatikus szöveggé alakításához, eseményekhez és élő feliratozáshoz.",
+        "enabled": {
+            "label": "Hangról szövegre alakítás engedélyezése"
+        }
     }
 }

web/public/locales/hu/config/global.json

@@ -40,5 +40,65 @@
     "environment_vars": {
         "label": "Környezeti változók",
         "description": "A Home Assistant OS rendszerben a Frigate folyamat számára beállítandó környezeti változói. A nem HAOS-felhasználóknak helyette a Docker konfigurációját kell használniuk."
+    },
+    "logger": {
+        "label": "Naplózás",
+        "description": "Az alapértelmezett naplózási részletességet és a komponensenkénti naplózási szintek felülírását vezérli.",
+        "default": {
+            "label": "Naplózási részletesség",
+            "description": "Alapértelmezett globális naplórészletesség (debug, info, warning, error)."
+        },
+        "logs": {
+            "label": "Folyamatonkénti naplózási szint",
+            "description": "Összetevőnkénti naplózási szint felülbírálások az egyes modulok részletességének növeléséhez vagy csökkentéséhez."
+        }
+    },
+    "audio": {
+        "label": "Hangesemények",
+        "enabled": {
+            "label": "Hangalapú eseményérzékelés engedélyezése"
+        },
+        "max_not_heard": {
+            "description": "Ennyi másodperc után fejeződik be a hangesemény, ha a beállított hangtípus nem észlelhető.",
+            "label": "Időtúllépés befejezése"
+        },
+        "min_volume": {
+            "label": "Minimális hangerő",
+            "description": "Minimum RMS hangerő a hangérzékelés futtatásához; az alacsonyabb értékek növelik az érzékenységet (pl: 200 magas, 500 közepes, 1000 alacsony érzékenységet jelent)."
+        },
+        "listen": {
+            "label": "Hallgatási típúsok",
+            "description": "Lista a hangalapú eseményekről amit érzékelni szeretnél (angolul) (például: bark, fire_alarm, scream, speech, yell)."
+        },
+        "filters": {
+            "label": "Audio szűrők (filters)",
+            "description": "Hangtípusonkénti szűrőbeállítások (filter), mint például a téves találatok számát mérsékelő konfidencia-küszöbök."
+        },
+        "enabled_in_config": {
+            "label": "Eredeti audio állapot"
+        }
+    },
+    "auth": {
+        "label": "Azonosítás",
+        "description": "Bejelentkezési és munkamenet-beállítások, többek között süti- és lekérdezési korlátok (rate limit) megadásához.",
+        "enabled": {
+            "label": "Bejelentkezés engedélyezése",
+            "description": "Natív bejelentkezés (azonosítás) engedélyezése a Frigate felületén."
+        },
+        "reset_admin_password": {
+            "label": "Admin jelszó visszaállítása",
+            "description": "Ha igaz, akkor visszaállítja az admin felhasználó jelszavát, és induláskor a naplóba írja ki az új jelszót."
+        },
+        "cookie_name": {
+            "label": "JWT süti neve",
+            "description": "A süti neve ami a JWT tokent tárolja a natív bejelentkezéshez."
+        }
+    },
+    "audio_transcription": {
+        "label": "Hang Feliratozás",
+        "description": "„Beállítások élő hang és beszéd automatikus szöveggé alakításához, eseményekhez és élő feliratozáshoz.",
+        "enabled": {
+            "label": "Hangról szövegre alakítás engedélyezése"
+        }
     }
 }

web/public/locales/hu/config/groups.json

@@ -16,5 +16,43 @@
         "cameras": {
             "appearance": "Kinézet"
         }
+    },
+    "motion": {
+        "global": {
+            "sensitivity": "Globális érzékenység",
+            "algorithm": "Globális Algoritmus"
+        },
+        "cameras": {
+            "sensitivity": "Érzékenység",
+            "algorithm": "Algoritmus"
+        }
+    },
+    "detect": {
+        "global": {
+            "resolution": "Globális Felbontás",
+            "tracking": "Globális követés"
+        },
+        "cameras": {
+            "resolution": "Felbontás",
+            "tracking": "Követés (tracking)"
+        }
+    },
+    "snapshots": {
+        "global": {
+            "display": "Globális kijelző"
+        },
+        "cameras": {
+            "display": "Kijelző"
+        }
+    },
+    "objects": {
+        "global": {
+            "tracking": "Globális objektumkövetés",
+            "filtering": "Globális szűrés (filtering)"
+        },
+        "cameras": {
+            "tracking": "Követés",
+            "filtering": "Szűrés (filtering)"
+        }
     }
 }

web/public/locales/hu/config/validation.json

@@ -4,5 +4,22 @@
     "exclusiveMinimum": "Nagyobbnak kell lennie, mint {{limit}}",
     "exclusiveMaximum": "Kevesebbnek kell lennie, mint {{limit}}",
     "minLength": "Legalább {{limit}} karaktert kell megadni",
-    "maxLength": "Legfeljebb {{limit}} karakter lehet"
+    "maxLength": "Legfeljebb {{limit}} karakter lehet",
+    "minItems": "Legalább {{limit}} elemnek kell lennie",
+    "maxItems": "Legfeljebb {{limit}} elem lehet",
+    "pattern": "Érvénytelen formátum",
+    "required": "Ezt a mezőt kötelező kitölteni",
+    "type": "Érvénytelen értéktípus",
+    "enum": "Az engedélyezett értékek közül legalább egy kell legyen",
+    "const": "Az érték nem egyezik a várt állandóval",
+    "uniqueItems": "Minden elemnek egyedinek kell lennie",
+    "format": "Érvénytelen formátum",
+    "additionalProperties": "Ismeretlen tulajdonság nem engedélyezett",
+    "oneOf": "Pontosan az egyik engedélyezett sémának kell megfelelnie",
+    "anyOf": "Legalább az egyik engedélyezett sémának kell megfelelnie",
+    "ffmpeg": {
+        "inputs": {
+            "rolesUnique": "Mindegyik szerepkör (role) csak egy bemeneti (input) streamhez rendelhető hozzá."
+        }
+    }
 }

web/public/locales/hu/views/events.json

@@ -15,7 +15,9 @@
     "only": "Csak mozgások"
   },
   "allCameras": "Összes kamera",
-  "timeline": "Idővonal",
+  "timeline": {
+    "label": "Idővonal"
+  },
   "detected": "észlelve",
   "events": {
     "label": "Események",

web/public/locales/hu/views/exports.json

@@ -3,7 +3,9 @@
   "search": "Keresés",
   "noExports": "Export nem található",
   "deleteExport.desc": "Biztos, hogy törölni akarja {{exportName}}-t?",
-  "deleteExport": "Export törlése",
+  "deleteExport": {
+    "label": "Export törlése"
+  },
   "editExport": {
     "title": "Exportálás átnevezése",
     "desc": "Adjon meg egy új nevet ennek az exportnak.",
@@ -23,5 +25,8 @@
   "headings": {
     "cases": "Esetek",
     "uncategorizedExports": "Kategória nélküli exportok"
+  },
+  "toolbar": {
+    "addExport": "Export hozzáadása"
   }
 }

web/public/locales/hu/views/live.json

@@ -3,7 +3,9 @@
     "enable": "Kétirányú kommunikáció engedélyezése",
     "disable": "Kétirányú kommunikáció tiltása"
   },
-  "documentTitle": "Élő - Frigate",
+  "documentTitle": {
+    "default": "Élő - Frigate"
+  },
   "lowBandwidthMode": "Alacsony felbontású mód",
   "documentTitle.withCamera": "{{camera}} - Élő - Frigate",
   "cameraAudio": {
@@ -15,7 +17,8 @@
       "clickMove": {
         "label": "Kattintson a képre a kamera középre igazításához",
         "enable": "Engedélyezze a kattintást a mozgatáshoz",
-        "disable": "Kattintással húzás kikapcsolása"
+        "disable": "Kattintással húzás kikapcsolása",
+        "enableWithZoom": "Kattintással történő mozgatás és húzással való nagyítás engedélyezése"
       },
       "left": {
         "label": "PTZ kamera balra mozgatása"

web/public/locales/hu/views/settings.json

@@ -12,7 +12,11 @@
     "motionTuner": "Mozgás Hangoló - Frigate",
     "enrichments": "Kiegészítés Beállítások - Frigate",
     "cameraManagement": "Kamerák kezelése - Frigate",
-    "cameraReview": "Kamera beállítások áttekintése – Frigate"
+    "cameraReview": "Kamera beállítások áttekintése – Frigate",
+    "globalConfig": "Globális Konfiguráció - Frigate",
+    "cameraConfig": "Kamera Konfiguráció - Frigate",
+    "maintenance": "Karbantartás - Fregatt",
+    "profiles": "Profilok - Fregatt"
   },
   "menu": {
     "ui": "UI",
@@ -28,7 +32,24 @@
     "triggers": "Triggerek",
     "roles": "Szerepkörök",
     "cameraManagement": "Menedzsment",
-    "cameraReview": "Vizsgálat"
+    "cameraReview": "Vizsgálat",
+    "general": "Általános",
+    "globalConfig": "Globális konfiguráció",
+    "system": "Rendszer",
+    "integrations": "Integrációk",
+    "uiSettings": "UI beállítások",
+    "profiles": "Profilok",
+    "globalDetect": "Tárgy felismerés",
+    "globalRecording": "Felvétel",
+    "globalSnapshots": "Pillanatképek",
+    "globalFfmpeg": "FFmpeg",
+    "globalMotion": "Mozgásérzékelés",
+    "globalObjects": "Tárgyak",
+    "globalReview": "Áttekintés",
+    "globalAudioEvents": "Hangesemények",
+    "cameraAudioEvents": "Hangesemények",
+    "cameraAudioTranscription": "Hang Feliratozás",
+    "integrationAudioTranscription": "Hang Feliratozás"
   },
   "dialog": {
     "unsavedChanges": {
@@ -861,5 +882,11 @@
       "streamConfiguration": "Stream beállítások",
       "validationAndTesting": "Validálás és tesztelés"
     }
+  },
+  "button": {
+    "overriddenGlobal": "Felülírt (Globális)",
+    "overriddenGlobalTooltip": "Ez a kamera felülírja a globális konfigurációs beállításokat ebben a részben",
+    "overriddenBaseConfig": "Felülírt (Alapbeállítás)",
+    "overriddenBaseConfigTooltip": "A {{profile}} profil felülírja a konfigurációs beállításokat ebben a részben"
   }
 }

web/public/locales/hu/views/system.json

@@ -6,7 +6,8 @@
     "logs": {
       "frigate": "Frigate naplók - Frigate",
       "go2rtc": "Go2RTC naplók - Frigate",
-      "nginx": "Nginx naplók - Frigate"
+      "nginx": "Nginx naplók - Frigate",
+      "websocket": "Üzenet naplók - Frigate"
     },
     "enrichments": "Kiegészítés statisztikák - Frigate"
   },
@@ -78,7 +79,19 @@
     "download": {
       "label": "Naplók letöltése"
     },
-    "tips": "A naplók a szerverről érkeznek"
+    "tips": "A naplók a szerverről érkeznek",
+    "websocket": {
+      "label": "Üzenetek",
+      "pause": "Szüneteltetés",
+      "resume": "Folytatás",
+      "filter": {
+        "all": "Összes téma (topic)",
+        "topics": "Témák (topics)",
+        "events": "Események",
+        "reviews": "Értékelések (reviews)",
+        "face_recognition": "Arcfelismerés"
+      }
+    }
   },
   "general": {
     "title": "Általános",

web/public/locales/id/views/settings.json

@@ -47,5 +47,21 @@
         "desc": "Secara otomatis beralih ke tampilan langsung kamera saat aktivitas terdeteksi. Menonaktifkan opsi ini menyebabkan gambar statis kamera di dasbor langsung hanya diperbarui sekali per menit."
       }
     }
+  },
+  "configMessages": {
+    "audioTranscription": {
+      "audioDetectionDisabled": "Pendeteksi suara tidak dinyalakan untuk kamera ini. Transkripsi suara memerlukan pendeteksi suara untuk dinyalakan."
+    },
+    "detect": {
+      "fpsGreaterThanFive": "Pengaturan FPS untuk pendeteksian lebih dari 5 tidak disarankan."
+    },
+    "faceRecognition": {
+      "globalDisabled": "Pendeteksi muka tidak dinyalakan dalam level global. Nyalakan pendeteksi muka dalam pengaturan global agar per-kamera deteksi muka dapat bekerja.",
+      "personNotTracked": "Pendeteksi muka memerlukan 'orang' sebagai objek deteksi. Pastikan 'orang' berada dalam hal yang dideteksi."
+    },
+    "lpr": {
+      "globalDisabled": "Pendeteksian plat nomor tidak dinyalakan dalam pengaturan global. Nyalakan deteksi plat nomor dalam pengaturan global agar fungsi ini dapat bekerja.",
+      "vehicleNotTracked": "Pendeteksian plat nomor memerlukan 'mobil' atau 'motor' untuk dideteksi."
+    }
   }
 }

web/public/locales/it/common.json

@@ -279,7 +279,7 @@
   },
   "pagination": {
     "next": {
-      "title": "Successiva",
+      "title": "Successivo",
       "label": "Vai alla pagina successiva"
     },
     "previous": {

web/public/locales/it/components/dialog.json

@@ -64,15 +64,28 @@
     "toast": {
       "success": "Esportazione avviata correttamente. Visualizza il file nella pagina delle esportazioni.",
       "error": {
-        "failed": "Impossibile avviare l'esportazione: {{error}}",
+        "failed": "Impossibile mettere in coda l'esportazione: {{error}}",
         "endTimeMustAfterStartTime": "L'ora di fine deve essere successiva all'ora di inizio",
         "noVaildTimeSelected": "Nessun intervallo di tempo valido selezionato"
       },
-      "view": "Visualizzazione"
+      "view": "Visualizzazione",
+      "queued": "Esportazione in coda. Visualizza lo stato di avanzamento nella pagina delle esportazioni.",
+      "batchSuccess_one": "Avviata 1 esportazione. Apertura del caso in corso.",
+      "batchSuccess_many": "Avviate {{count}} esportazioni. Apertura del caso in corso.",
+      "batchSuccess_other": "Avviate {{count}} esportazioni. Apertura del caso in corso.",
+      "batchPartial": "Avviate {{successful}} esportazioni su un totale di {{total}}. Telecamere non riuscite: {{failedCameras}}",
+      "batchFailed": "Impossibile avviare {{total}} esportazioni. Telecamere non riuscite: {{failedCameras}}",
+      "batchQueuedSuccess_one": "1 esportazione in coda. Apertura del caso in corso.",
+      "batchQueuedSuccess_many": "Sono in coda {{count}} esportazioni. Apertura del caso in corso.",
+      "batchQueuedSuccess_other": "Sono in coda {{count}} esportazioni. Apertura del caso in corso.",
+      "batchQueuedPartial": "In coda {{successful}} di {{total}} esportazioni. Telecamere non riuscite: {{failedCameras}}",
+      "batchQueueFailed": "Impossibile mettere in coda {{total}} esportazioni. Telecamere non riuscite: {{failedCameras}}"
     },
     "fromTimeline": {
       "saveExport": "Salva esportazione",
-      "previewExport": "Anteprima esportazione"
+      "previewExport": "Anteprima esportazione",
+      "queueingExport": "Accodamento per l'esportazione...",
+      "useThisRange": "Utilizza questa intervallo"
     },
     "select": "Seleziona",
     "name": {
@@ -80,7 +93,55 @@
     },
     "case": {
       "label": "Caso",
-      "placeholder": "Seleziona un caso"
+      "placeholder": "Seleziona un caso",
+      "newCaseOption": "Crea un nuovo caso",
+      "newCaseNamePlaceholder": "Nuovo nome del caso",
+      "newCaseDescriptionPlaceholder": "Descrizione del caso",
+      "nonAdminHelp": "Per queste esportazioni verrà creato un nuovo caso."
+    },
+    "queueing": "Accodamento per l'esportazione...",
+    "tabs": {
+      "export": "Telecamera singola",
+      "multiCamera": "Multicamera"
+    },
+    "multiCamera": {
+      "timeRange": "Intervallo di tempo",
+      "selectFromTimeline": "Seleziona dalla cronologia",
+      "cameraSelection": "Telecamere",
+      "cameraSelectionHelp": "Le telecamere con oggetti tracciati in questo intervallo di tempo sono preselezionate",
+      "checkingActivity": "Controllo dell'attività della telecamera...",
+      "noCameras": "Nessuna telecamera disponibile",
+      "detectionCount_one": "1 oggetto tracciato",
+      "detectionCount_many": "{{count}} oggetti tracciati",
+      "detectionCount_other": "{{count}} oggetti tracciati",
+      "nameLabel": "Nome di esportazione",
+      "namePlaceholder": "Nome base facoltativo per queste esportazioni",
+      "queueingButton": "Accodamento delle esportazioni...",
+      "exportButton_one": "Esporta 1 telecamera",
+      "exportButton_many": "Esporta {{count}} telecamere",
+      "exportButton_other": "Esporta {{count}} telecamere"
+    },
+    "multi": {
+      "title_one": "Esporta 1 revisione",
+      "title_many": "Esporta {{count}} revisioni",
+      "title_other": "Esporta {{count}} revisioni",
+      "description": "Esporta ogni revisione selezionata. Tutte le esportazioni saranno raggruppate in un unico caso.",
+      "descriptionNoCase": "Esporta ogni revisione selezionata.",
+      "caseNamePlaceholder": "Esporta revisione - {{date}}",
+      "exportButton_one": "Esporta 1 revisione",
+      "exportButton_many": "Esporta {{count}} revisioni",
+      "exportButton_other": "Esporta {{count}} revisioni",
+      "exportingButton": "Esportazione...",
+      "toast": {
+        "started_one": "Avviata 1 esportazione. Apertura del caso in corso.",
+        "started_many": "Avviate {{count}} esportazioni. Apertura del caso in corso.",
+        "started_other": "Avviate {{count}} esportazioni. Apertura del caso in corso.",
+        "startedNoCase_one": "Avviata 1 esportazione.",
+        "startedNoCase_many": "Avviate {{count}} esportazioni.",
+        "startedNoCase_other": "Avviate {{count}} esportazioni.",
+        "partial": "Avviate {{successful}} esportazioni su un totale di {{total}}. Fallite: {{failedItems}}",
+        "failed": "Impossibile avviare {{total}} esportazioni. Errori: {{failedItems}}"
+      }
     }
   },
   "streaming": {
@@ -128,6 +189,14 @@
         "success": "Il filmato associato agli elementi di recensione selezionati è stato eliminato correttamente.",
         "error": "Impossibile eliminare: {{error}}"
       }
+    },
+    "shareTimestamp": {
+      "label": "Condividi orario",
+      "title": "Condividi orario",
+      "description": "Condividi un URL con l'orario della posizione attuale del lettore oppure scegli un orario personalizzato. Tieni presente che questo URL non è pubblico ed è accessibile solo agli utenti che hanno accesso a Frigate e a questa telecamera.",
+      "custom": "Orario personalizzato",
+      "button": "URL dell'orario di condivisione",
+      "shareTitle": "Orario revisione Frigate: {{camera}}"
     }
   },
   "imagePicker": {

web/public/locales/it/components/player.json

@@ -4,7 +4,8 @@
   "noPreviewFoundFor": "Nessuna anteprima trovata per {{cameraName}}",
   "submitFrigatePlus": {
     "title": "Vuoi inviare questo fotogramma a Frigate+?",
-    "submit": "Invia"
+    "submit": "Invia",
+    "previewError": "Impossibile caricare l'anteprima dell'istantanea. La registrazione potrebbe non essere disponibile al momento."
   },
   "livePlayerRequiredIOSVersion": "Per questo tipo di trasmissione dal vivo è richiesto iOS 17.1 o versione successiva.",
   "stats": {
@@ -47,5 +48,5 @@
       "submitFrigatePlusFailed": "Impossibile inviare il fotogramma a Frigate+"
     }
   },
-  "cameraDisabled": "La telecamera è disattivata"
+  "cameraDisabled": "La telecamera è disabilita"
 }

web/public/locales/it/config/cameras.json

@@ -20,12 +20,87 @@
             "description": "Abilita o disabilita il rilevamento degli eventi audio per questa telecamera."
         },
         "min_volume": {
-            "label": "Volume minimo"
+            "label": "Volume minimo",
+            "description": "È richiesta una soglia minima di volume RMS per eseguire il rilevamento audio; valori inferiori aumentano la sensibilità (ad esempio, 200 alta, 500 media, 1000 bassa)."
+        },
+        "max_not_heard": {
+            "label": "Fine pausa",
+            "description": "Numero di secondi senza il tipo di audio configurato prima che l'evento audio termini."
+        },
+        "listen": {
+            "label": "Tipi di ascolto",
+            "description": "Elenco dei tipi di eventi audio da rilevare (ad esempio: abbaio, allarme antincendio, urlo, parlato, grido)."
+        },
+        "filters": {
+            "label": "Filtri audio",
+            "description": "Impostazioni di filtro per ciascun tipo di audio, come le soglie di confidenza utilizzate per ridurre i falsi positivi."
+        },
+        "enabled_in_config": {
+            "label": "Stato audio originale",
+            "description": "Indica se il rilevamento audio era originariamente abilitato nel file di configurazione statico."
+        },
+        "num_threads": {
+            "label": "Processi di rilevamento",
+            "description": "Numero di processi da utilizzare per l'elaborazione del rilevamento audio."
         }
     },
     "ffmpeg": {
         "path": {
             "label": "Percorso FFmpeg"
         }
+    },
+    "audio_transcription": {
+        "label": "Trascrizione audio",
+        "description": "Impostazioni per la trascrizione audio in tempo reale e del parlato utilizzata per eventi e sottotitoli in tempo reale.",
+        "enabled": {
+            "label": "Abilita la trascrizione",
+            "description": "Abilita o disabilita la trascrizione manuale degli eventi audio."
+        }
+    },
+    "mqtt": {
+        "label": "MQTT"
+    },
+    "onvif": {
+        "tls_insecure": {
+            "label": "Disabilita verifica TLS"
+        },
+        "profile": {
+            "label": "Profilo ONVIF"
+        },
+        "autotracking": {
+            "label": "Tracciamento automatico",
+            "enabled": {
+                "label": "Abilita il tracciamento automatico"
+            },
+            "calibrate_on_startup": {
+                "label": "Calibra all'avvio"
+            },
+            "zooming": {
+                "label": "Modalità ingrandimento"
+            },
+            "zoom_factor": {
+                "label": "Fattore di ingrandimento"
+            },
+            "track": {
+                "label": "Oggetti tracciati",
+                "description": "Elenco dei tipi di oggetto che dovrebbero attivare il tracciamento automatico."
+            },
+            "required_zones": {
+                "label": "Zone richieste"
+            },
+            "timeout": {
+                "label": "Scadenza di ritorno",
+                "description": "Attendi questo numero di secondi dopo aver perso il tracciamento prima di riportare la telecamera nella posizione preimpostata."
+            },
+            "movement_weights": {
+                "description": "Valori di calibrazione generati automaticamente dalla calibrazione della telecamera. Non modificare manualmente."
+            },
+            "enabled_in_config": {
+                "label": "Stato originale del tracciamento automatico"
+            }
+        },
+        "ignore_time_mismatch": {
+            "label": "Ignora la discrepanza oraria"
+        }
     }
 }

web/public/locales/it/config/global.json

@@ -17,7 +17,28 @@
             "label": "Abilita il rilevamento audio"
         },
         "min_volume": {
-            "label": "Volume minimo"
+            "label": "Volume minimo",
+            "description": "È richiesta una soglia minima di volume RMS per eseguire il rilevamento audio; valori inferiori aumentano la sensibilità (ad esempio, 200 alta, 500 media, 1000 bassa)."
+        },
+        "max_not_heard": {
+            "label": "Fine pausa",
+            "description": "Numero di secondi senza il tipo di audio configurato prima che l'evento audio termini."
+        },
+        "listen": {
+            "label": "Tipi di ascolto",
+            "description": "Elenco dei tipi di eventi audio da rilevare (ad esempio: abbaio, allarme antincendio, urlo, parlato, grido)."
+        },
+        "filters": {
+            "label": "Filtri audio",
+            "description": "Impostazioni di filtro per ciascun tipo di audio, come le soglie di confidenza utilizzate per ridurre i falsi positivi."
+        },
+        "enabled_in_config": {
+            "label": "Stato audio originale",
+            "description": "Indica se il rilevamento audio era originariamente abilitato nel file di configurazione statico."
+        },
+        "num_threads": {
+            "label": "Processi di rilevamento",
+            "description": "Numero di processi da utilizzare per l'elaborazione del rilevamento audio."
         }
     },
     "logger": {
@@ -29,7 +50,8 @@
         "logs": {
             "label": "Livello di registro per processo",
             "description": "Opzioni di sovrsacrittura del livello di registro per ciascun componente, per aumentare o diminuire il livello di dettaglio dei singoli moduli."
-        }
+        },
+        "label": "Registro"
     },
     "auth": {
         "label": "Autenticazione",
@@ -41,11 +63,130 @@
         "reset_admin_password": {
             "label": "Reimposta la password di amministratore",
             "description": "Se la condizione è vera, reimposta la password dell'utente amministratore all'avvio e stampa la nuova password nei registri."
+        },
+        "cookie_name": {
+            "label": "Nome del cookie JWT",
+            "description": "Nome del cookie utilizzato per memorizzare il token JWT per l'autenticazione nativa."
+        },
+        "cookie_secure": {
+            "label": "Attributo dei cookie sicuri",
+            "description": "Imposta l'attributo 'sicuro' sul cookie di autenticazione; deve essere impostato su 'vero' quando si utilizza TLS."
+        },
+        "session_length": {
+            "label": "Durata della sessione",
+            "description": "Durata della sessione in secondi per le sessioni basate su JWT."
+        },
+        "refresh_time": {
+            "label": "Finestra di aggiornamento della sessione",
+            "description": "Quando una sessione sta per scadere entro questo numero di secondi, aggiornala per ripristinarne la durata completa."
+        },
+        "trusted_proxies": {
+            "label": "Proxy affidabili",
+            "description": "Elenco degli indirizzi IP proxy attendibili utilizzati per determinare l'indirizzo IP del client ai fini della limitazione della velocità."
+        },
+        "roles": {
+            "label": "Mappatura dei ruoli"
         }
     },
     "ffmpeg": {
         "path": {
             "label": "Percorso FFmpeg"
         }
+    },
+    "detectors": {
+        "cpu": {
+            "num_threads": {
+                "label": "Numero di processi di rilevamento",
+                "description": "Il numero di processi utilizzati per l'inferenza basata sulla CPU."
+            }
+        }
+    },
+    "audio_transcription": {
+        "label": "Trascrizione audio",
+        "description": "Impostazioni per la trascrizione audio in tempo reale e del parlato utilizzata per eventi e sottotitoli in tempo reale.",
+        "enabled": {
+            "label": "Abilita la trascrizione audio"
+        }
+    },
+    "mqtt": {
+        "label": "MQTT",
+        "enabled": {
+            "label": "Abilita MQTT"
+        },
+        "host": {
+            "label": "Sistema MQTT",
+            "description": "Nome sistema o indirizzo IP del broker MQTT."
+        },
+        "port": {
+            "label": "Porta MQTT",
+            "description": "Porta del broker MQTT (solitamente 1883 per MQTT standard)."
+        },
+        "topic_prefix": {
+            "label": "Prefisso argomento"
+        },
+        "client_id": {
+            "label": "ID client"
+        },
+        "stats_interval": {
+            "label": "Intervallo statistiche"
+        },
+        "user": {
+            "label": "Nome utente MQTT",
+            "description": "Nome utente MQTT facoltativo; può essere fornito tramite variabili d'ambiente o segreti."
+        },
+        "password": {
+            "label": "Password MQTT",
+            "description": "Password MQTT facoltativa; può essere fornita tramite variabili d'ambiente o segreti."
+        },
+        "tls_ca_certs": {
+            "label": "Certificati CA TLS",
+            "description": "Percorso al certificato CA per le connessioni TLS al broker (per certificati autofirmati)."
+        },
+        "tls_client_cert": {
+            "label": "Certificato client"
+        }
+    },
+    "onvif": {
+        "tls_insecure": {
+            "label": "Disabilita verifica TLS"
+        },
+        "profile": {
+            "label": "Profilo ONVIF"
+        },
+        "autotracking": {
+            "label": "Tracciamento automatico",
+            "enabled": {
+                "label": "Abilita il tracciamento automatico"
+            },
+            "calibrate_on_startup": {
+                "label": "Calibra all'avvio"
+            },
+            "zooming": {
+                "label": "Modalità ingrandimento"
+            },
+            "zoom_factor": {
+                "label": "Fattore di ingrandimento"
+            },
+            "track": {
+                "label": "Oggetti tracciati",
+                "description": "Elenco dei tipi di oggetto che dovrebbero attivare il tracciamento automatico."
+            },
+            "required_zones": {
+                "label": "Zone richieste"
+            },
+            "timeout": {
+                "label": "Scadenza di ritorno",
+                "description": "Attendi questo numero di secondi dopo aver perso il tracciamento prima di riportare la telecamera nella posizione preimpostata."
+            },
+            "movement_weights": {
+                "description": "Valori di calibrazione generati automaticamente dalla calibrazione della telecamera. Non modificare manualmente."
+            },
+            "enabled_in_config": {
+                "label": "Stato originale del tracciamento automatico"
+            }
+        },
+        "ignore_time_mismatch": {
+            "label": "Ignora la discrepanza oraria"
+        }
     }
 }

web/public/locales/it/config/validation.json

@@ -4,5 +4,29 @@
     "exclusiveMinimum": "Deve essere maggiore di {{limit}}",
     "exclusiveMaximum": "Deve essere minore di {{limit}}",
     "minLength": "Deve essere almeno {{limit}} carattere(i)",
-    "maxLength": "Deve essere al massimo {{limit}} carattere(i)"
+    "maxLength": "Deve essere al massimo {{limit}} carattere(i)",
+    "minItems": "Deve contenere almeno {{limit}} elementi",
+    "maxItems": "Deve avere al massimo {{limit}} elementi",
+    "pattern": "Formato non valido",
+    "required": "Questo campo è obbligatorio",
+    "type": "Tipo di valore non valido",
+    "enum": "Deve essere uno dei valori consentiti",
+    "const": "Il valore non corrisponde alla costante prevista",
+    "uniqueItems": "Tutti gli elementi devono essere unici",
+    "format": "Formato non valido",
+    "additionalProperties": "Proprietà sconosciuta non consentita",
+    "oneOf": "Deve corrispondere esattamente a uno degli schemi consentiti",
+    "anyOf": "Deve corrispondere ad almeno uno degli schemi consentiti",
+    "proxy": {
+        "header_map": {
+            "roleHeaderRequired": "L'intestazione del ruolo è obbligatoria quando si configurano le mappature dei ruoli."
+        }
+    },
+    "ffmpeg": {
+        "inputs": {
+            "rolesUnique": "Ciascun ruolo può essere assegnato a un solo flusso di ingresso.",
+            "detectRequired": "Ad almeno un flusso di ingresso deve essere assegnato il ruolo di 'rilevamento'.",
+            "hwaccelDetectOnly": "Solo il flusso di ingresso con il ruolo di rilevamento può definire argomenti di accelerazione hardware."
+        }
+    }
 }

web/public/locales/it/views/events.json

@@ -22,7 +22,9 @@
   "markAsReviewed": "Segna come visto",
   "documentTitle": "Rivedi - Frigate",
   "allCameras": "Tutte le camere",
-  "timeline": "Cronologia",
+  "timeline": {
+    "label": "Linea temporale"
+  },
   "timeline.aria": "Seleziona la cronologia",
   "events": {
     "label": "Eventi",
@@ -30,7 +32,9 @@
     "noFoundForTimePeriod": "Nessun evento trovato per questo intervallo."
   },
   "recordings": {
-    "documentTitle": "Registrazioni - Frigate"
+    "documentTitle": "Registrazioni - Frigate",
+    "invalidSharedLink": "Impossibile aprire il collegamento alla registrazione con orario a causa di un errore di analisi.",
+    "invalidSharedCamera": "Impossibile aprire il collegamento alla registrazione con orario a causa di una telecamera sconosciuta o non autorizzata."
   },
   "calendarFilter": {
     "last24Hours": "Ultime 24 ore"
@@ -44,7 +48,7 @@
   "threateningActivity": "Attività minacciosa",
   "detail": {
     "noDataFound": "Nessun dato dettagliato da rivedere",
-    "aria": "Attiva/disattiva la visualizzazione dettagliata",
+    "aria": "Abilita/disabilita la visualizzazione dettagliata",
     "trackedObject_one": "{{count}} oggetto",
     "trackedObject_other": "{{count}} oggetti",
     "noObjectDetailData": "Non sono disponibili dati dettagliati sull'oggetto.",
@@ -64,5 +68,28 @@
   "normalActivity": "Normale",
   "needsReview": "Necessita revisione",
   "securityConcern": "Rischio per la sicurezza",
-  "select_all": "Tutti"
+  "select_all": "Tutti",
+  "motionSearch": {
+    "menuItem": "Ricerca movimento",
+    "openMenu": "Opzioni telecamera"
+  },
+  "motionPreviews": {
+    "title": "Anteprime di movimento: {{camera}}",
+    "mobileSettingsTitle": "Impostazioni di anteprima del movimento",
+    "mobileSettingsDesc": "Regola la velocità di riproduzione e la luminosità, poi scegli una data per rivedere i filmati che mostrano solo il movimento.",
+    "dim": "Attenua",
+    "dimAria": "Regola l'intensità della luce",
+    "dimDesc": "Aumenta l'attenuazione per migliorare la visibilità delle aree in movimento.",
+    "speed": "Velocità",
+    "speedAria": "Seleziona la velocità di riproduzione dell'anteprima",
+    "speedDesc": "Scegli la velocità di riproduzione dei video di anteprima.",
+    "back": "Indietro",
+    "empty": "Nessuna anteprima disponibile",
+    "noPreview": "Anteprima non disponibile",
+    "seekAria": "Cerca il riproduttore {{camera}} a {{time}}",
+    "filter": "Filtro",
+    "filterDesc": "Seleziona le aree per visualizzare solo i video con movimento in quelle regioni.",
+    "filterClear": "Pulisci",
+    "menuItem": "Visualizza le anteprime del movimento"
+  }
 }

web/public/locales/it/views/explore.json

@@ -289,7 +289,10 @@
         "zones": "Zone",
         "ratio": "Rapporto",
         "area": "Area",
-        "score": "Punteggio"
+        "score": "Punteggio",
+        "computedScore": "Punteggio calcolato",
+        "topScore": "Punteggio massimo",
+        "toggleAdvancedScores": "Attiva/disattiva i punteggi avanzati"
       }
     },
     "annotationSettings": {

web/public/locales/it/views/exports.json

@@ -14,7 +14,9 @@
   "toast": {
     "error": {
       "renameExportFailed": "Impossibile rinominare l'esportazione: {{errorMessage}}",
-      "assignCaseFailed": "Impossibile aggiornare l'assegnazione del caso: {{errorMessage}}"
+      "assignCaseFailed": "Impossibile aggiornare l'assegnazione del caso: {{errorMessage}}",
+      "caseSaveFailed": "Impossibile salvare il caso: {{errorMessage}}",
+      "caseDeleteFailed": "Impossibile eliminare il caso: {{errorMessage}}"
     }
   },
   "tooltip": {
@@ -22,7 +24,8 @@
     "downloadVideo": "Scarica video",
     "editName": "Modifica nome",
     "deleteExport": "Elimina esportazione",
-    "assignToCase": "Aggiungi al caso"
+    "assignToCase": "Aggiungi al caso",
+    "removeFromCase": "Rimuovi dal caso"
   },
   "headings": {
     "cases": "Casi",
@@ -35,5 +38,91 @@
     "newCaseOption": "Crea un nuovo caso",
     "nameLabel": "Nome del caso",
     "descriptionLabel": "Descrizione"
+  },
+  "toolbar": {
+    "newCase": "Nuovo caso",
+    "addExport": "Aggiungi esportazione",
+    "editCase": "Modifica caso",
+    "deleteCase": "Elimina il caso"
+  },
+  "deleteCase": {
+    "label": "Eliminare il caso",
+    "desc": "Sei sicuro di voler eliminare {{caseName}}?",
+    "descKeepExports": "Le esportazioni rimarranno disponibili come esportazioni non categorizzate.",
+    "descDeleteExports": "In questo caso, tutte le esportazioni verranno eliminate definitivamente.",
+    "deleteExports": "Elimina anche le esportazioni"
+  },
+  "caseCard": {
+    "emptyCase": "Ancora nessuna esportazione"
+  },
+  "jobCard": {
+    "defaultName": "{{camera}} esporta",
+    "queued": "In coda",
+    "running": "In esecuzione",
+    "preparing": "Preparazione",
+    "copying": "Copia",
+    "encoding": "Codifica",
+    "encodingRetry": "Codifica (riprova)",
+    "finalizing": "Finalizzazione"
+  },
+  "caseView": {
+    "noDescription": "Nessuna descrizione",
+    "createdAt": "Creato {{value}}",
+    "exportCount_one": "1 esportazione",
+    "exportCount_other": "{{count}} esportazioni",
+    "cameraCount_one": "1 telecamera",
+    "cameraCount_other": "{{count}} telecamere",
+    "showMore": "Mostra altro",
+    "showLess": "Mostra meno",
+    "emptyTitle": "Questo caso è vuoto",
+    "emptyDescription": "Aggiungi le esportazioni esistenti non categorizzate per mantenere il caso organizzato.",
+    "emptyDescriptionNoExports": "Al momento non sono disponibili esportazioni non categorizzate da aggiungere."
+  },
+  "caseEditor": {
+    "createTitle": "Crea un caso",
+    "editTitle": "Modifica caso",
+    "namePlaceholder": "Nome del caso",
+    "descriptionPlaceholder": "Aggiungi note o contesto per questo caso"
+  },
+  "addExportDialog": {
+    "title": "Aggiungi l'esportazione a {{caseName}}",
+    "searchPlaceholder": "Cerca esportazioni non categorizzate",
+    "empty": "Nessuna esportazione non categorizzata corrisponde a questa ricerca.",
+    "addButton_one": "Aggiungi 1 esportazione",
+    "addButton_other": "Aggiungi {{count}} esportazioni",
+    "adding": "In aggiunta..."
+  },
+  "selected_one": "{{count}} selezionati",
+  "selected_other": "{{count}} selezionati",
+  "bulkActions": {
+    "addToCase": "Aggiungi al caso",
+    "moveToCase": "Sposta al caso",
+    "removeFromCase": "Rimuovi dal caso",
+    "delete": "Elimina",
+    "deleteNow": "Elimina ora"
+  },
+  "bulkDelete": {
+    "title": "Elimina le esportazioni",
+    "desc_one": "Sei sicuro di voler eliminare l'esportazione {{count}}?",
+    "desc_other": "Sei sicuro di voler eliminare {{count}} esportazioni?"
+  },
+  "bulkRemoveFromCase": {
+    "title": "Rimuovi dal caso",
+    "desc_one": "Rimuovere l'esportazione {{count}} da questo caso?",
+    "desc_other": "Rimuovere {{count}} esportazioni da questo caso?",
+    "descKeepExports": "Le esportazioni verranno spostate nella categoria \"non classificate\".",
+    "descDeleteExports": "Le esportazioni verranno eliminate definitivamente.",
+    "deleteExports": "Elimina almeno le esportazioni"
+  },
+  "bulkToast": {
+    "success": {
+      "delete": "Esportazioni eliminate con successo",
+      "reassign": "Assegnazione del caso aggiornata con successo",
+      "remove": "Esportazioni rimosse con successo dal caso"
+    },
+    "error": {
+      "deleteFailed": "Impossibile eliminare le esportazioni: {{errorMessage}}",
+      "reassignFailed": "Impossibile aggiornare l'assegnazione del caso: {{errorMessage}}"
+    }
   }
 }