style: auto-fix lint and format

apps/docs/docs/integrations/fileflows/index.mdx

@@ -0,0 +1,36 @@
+---
+title: 'FileFlows'
+description: "FileFlows is a distributed media processing system that allows you to encode, compress and process your media files across multiple nodes."
+hide_title: true
+---
+
+import { IntegrationHeader } from '@site/src/components/integrations/header';
+import { IntegrationCapabilites } from '@site/src/components/integrations/widgets';
+import { AddingIntegration } from '@site/src/components/integrations/adding';
+import {IntegrationSecrets} from '@site/src/components/integrations/secrets';
+import { IconTransform } from "@tabler/icons-react";
+import { fileFlowsIntegration } from '.';
+import { mediaTranscodingWidget } from '@site/docs/widgets/media-transcoding';
+
+
+<IntegrationHeader
+  integration={fileFlowsIntegration}
+  categories={['Media Transcoding']}
+/>
+
+### Widgets & Capabilities
+<IntegrationCapabilites
+    items={[{ widget: mediaTranscodingWidget }]}
+/>
+
+### Adding the integration
+<AddingIntegration />
+
+### Secrets
+<IntegrationSecrets secrets={[{
+    credentials: ['apiKey'],
+    steps: []
+}, {
+    credentials: [],
+    steps: []
+}]} />

apps/docs/docs/integrations/fileflows/index.ts

@@ -0,0 +1,8 @@
+import { IntegrationDefinition } from "@site/src/types";
+export const fileFlowsIntegration: IntegrationDefinition = {
+  name: "FileFlows",
+  description:
+    "FileFlows is a distributed media processing system that allows you to encode, compress and process your media files across multiple nodes.",
+  iconUrl: "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/png/fileflows.png",
+  path: "../../integrations/fileflows",
+};

packages/api/src/router/widgets/dawarich.ts

@@ -1,27 +0,0 @@
-import { z } from "zod/v4";
-
-import { createOneIntegrationMiddleware } from "../../middlewares/integration";
-import { createTRPCRouter, publicProcedure } from "../../trpc";
-
-export const dawarichRouter = createTRPCRouter({
-  getStatistics: publicProcedure.concat(createOneIntegrationMiddleware("query", "dawarich")).query(async ({ ctx }) => {
-    const { dawarichStatisticsRequestHandler } = await import("@homarr/request-handler/dawarich");
-    const innerHandler = dawarichStatisticsRequestHandler.handler(ctx.integration, {});
-    const data = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-    return data.data;
-  }),
-
-  getPlaces: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", "dawarich"))
-    .input(
-      z.object({
-        limit: z.number().min(1).max(50).default(10),
-      }),
-    )
-    .query(async ({ ctx, input }) => {
-      const { dawarichPlacesRequestHandler } = await import("@homarr/request-handler/dawarich");
-      const innerHandler = dawarichPlacesRequestHandler.handler(ctx.integration, {});
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-      return data.slice(0, input.limit);
-    }),
-});

packages/api/src/router/widgets/index.ts

@@ -39,5 +39,4 @@ export const widgetRouter = createTRPCRouter({
   vpn: lazy(() => import("./vpn").then((mod) => mod.vpnRouter)),
   ups: lazy(() => import("./ups").then((mod) => mod.upsRouter)),
   customApi: lazy(() => import("./custom-api").then((mod) => mod.customApiRouter)),
-  dawarich: lazy(() => import("./dawarich").then((mod) => mod.dawarichRouter)),
 });

packages/definitions/src/docker-integration-match.ts

@@ -36,6 +36,7 @@ const integrationAliases: Partial<Record<IntegrationKind, readonly string[]>> =
   linuxServerIO: ["linuxserver"],
   coolify: ["coolify"],
   truenas: ["truenas"],
+  fileFlows: ["fileflows"],
 };
 
 export const matchIntegrationKind = (search: string): IntegrationKind | null => {

packages/definitions/src/docs/homarr-docs-sitemap.ts

@@ -312,6 +312,7 @@ export type HomarrDocumentationPath =
   | "/docs/integrations/dash-dot"
   | "/docs/integrations/glances"
   | "/docs/integrations/tdarr"
+  | "/docs/integrations/fileflows"
   | "/docs/integrations/proxmox"
   | "/docs/integrations/nextcloud"
   | "/docs/integrations/unifi-controller"
@@ -343,7 +344,6 @@ export type HomarrDocumentationPath =
   | "/docs/integrations/gluetun"
   | "/docs/integrations/peanut"
   | "/docs/integrations/beszel"
-  | "/docs/integrations/dawarich"
   | "/docs/widgets/clock"
   | "/docs/widgets/weather"
   | "/docs/widgets/app"

packages/definitions/src/docs/integration-doc-slugs.ts

@@ -27,6 +27,7 @@ export const integrationDocSlugs: Record<IntegrationKind, string | null> = {
   dashDot: "dash-dot",
   glances: "glances",
   tdarr: "tdarr",
+  fileFlows: "fileflows",
   proxmox: "proxmox",
   nextcloud: "nextcloud",
   unifiController: "unifi-controller",
@@ -59,6 +60,5 @@ export const integrationDocSlugs: Record<IntegrationKind, string | null> = {
   peaNut: "peanut",
   beszel: "beszel",
   archiveTeamWarrior: null,
-  dawarich: "dawarich",
   mock: null,
 };

packages/definitions/src/docs/widget-doc-slugs.ts

@@ -51,6 +51,4 @@ export const widgetDocSlugs: Record<WidgetKind, string | null> = {
   beszelAlerts: "beszel-alerts",
   beszelSystemStats: "beszel-system-stats",
   customApi: "custom-api",
-  dawarichStatistics: null,
-  dawarichPlaces: null,
 };

packages/definitions/src/integration.ts

@@ -251,6 +251,14 @@ export const integrationDefs = {
     documentationUrl: createDocumentationLink("/docs/integrations/tdarr"),
     defaultPort: 8265,
   },
+  fileFlows: {
+    name: "FileFlows",
+    secretKinds: [[], ["apiKey"]],
+    iconUrl: "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons@master/png/fileflows.png",
+    category: ["mediaTranscoding"],
+    documentationUrl: createDocumentationLink("/docs/integrations/fileflows"),
+    defaultPort: 5000,
+  },
   proxmox: {
     name: "Proxmox",
     secretKinds: [["username", "tokenId", "apiKey", "realm"]],
@@ -504,13 +512,6 @@ export const integrationDefs = {
     defaultUrl: "http://localhost:8001",
     documentationUrl: createDocumentationLink("/docs/integrations/archiveteam-warrior"),
   },
-  dawarich: {
-    name: "Dawarch",
-    secretKinds: [["apiKey"]],
-    iconUrl: "https://cdn.jsdelivr.net/gh/selfhst/icons/png/dawarich.png",
-    category: ["geolocationTracking"],
-    documentationUrl: createDocumentationLink("/docs/integrations/dawarich"),
-  },
   // This integration only returns mock data, it is used during development (but can also be used in production by directly going to the create page)
   mock: {
     name: "Mock",
@@ -624,7 +625,6 @@ export const integrationCategories = [
   "documents",
   "mediaLibrary",
   "uptimeMonitoring",
-  "geolocationTracking",
 ] as const;
 
 export type IntegrationCategory = (typeof integrationCategories)[number];

packages/definitions/src/widget-integration-map.ts

@@ -40,8 +40,6 @@ export const widgetIntegrationSupport: Partial<Record<WidgetKind, readonly Integ
   audioStats: ["navidrome", "audiobookshelf"],
   vpn: getIntegrationKindsByCategory("vpn"),
   anchorNote: ["anchor"],
-  dawarichStatistics: ["dawarich"],
-  dawarichPlaces: ["dawarich"],
 };
 
 export const getWidgetKindsForIntegration = (integrationKind: IntegrationKind): WidgetKind[] => {

packages/definitions/src/widget.ts

@@ -49,8 +49,6 @@ export const widgetKinds = [
   "beszelAlerts",
   "beszelSystemStats",
   "customApi",
-  "dawarichStatistics",
-  "dawarichPlaces",
 ] as const;
 export type WidgetKind = (typeof widgetKinds)[number];
 

packages/integrations/src/base/creator.ts

@@ -33,6 +33,7 @@ import { RadarrIntegration } from "../media-organizer/radarr/radarr-integration"
 import { ReadarrIntegration } from "../media-organizer/readarr/readarr-integration";
 import { SonarrIntegration } from "../media-organizer/sonarr/sonarr-integration";
 import { TdarrIntegration } from "../media-transcoding/tdarr-integration";
+import { FileFlowsIntegration } from "../media-transcoding/fileflows-integration";
 import { MockIntegration } from "../mock/mock-integration";
 import { NavidromeIntegration } from "../navidrome/navidrome-integration";
 import { NextcloudIntegration } from "../nextcloud/nextcloud.integration";
@@ -60,7 +61,6 @@ import { UptimeKumaIntegration } from "../uptime-kuma/uptime-kuma-integration";
 import { UnifiControllerIntegration } from "../unifi-controller/unifi-controller-integration";
 import { UnraidIntegration } from "../unraid/unraid-integration";
 import type { Integration, IntegrationInput } from "./integration";
-import { DawarichIntegration } from "../dawarich/dawarich-integration";
 
 export const createIntegrationAsync = async <TKind extends keyof typeof integrationCreators>(
   integration: IntegrationInput & { kind: TKind },
@@ -110,6 +110,7 @@ export const integrationCreators = {
   readarr: ReadarrIntegration,
   dashDot: DashDotIntegration,
   tdarr: TdarrIntegration,
+  fileFlows: FileFlowsIntegration,
   proxmox: ProxmoxIntegration,
   emby: EmbyIntegration,
   nextcloud: NextcloudIntegration,
@@ -144,7 +145,6 @@ export const integrationCreators = {
   uptimeKuma: UptimeKumaIntegration,
   peaNut: PeaNutIntegration,
   beszel: BeszelIntegration,
-  dawarich: DawarichIntegration,
 } satisfies Record<IntegrationKind, IntegrationInstance | [(input: IntegrationInput) => Promise<Integration>]>;
 
 type IntegrationInstanceOfKind<TKind extends keyof typeof integrationCreators> = {

packages/integrations/src/dawarich/dawarich-integration.ts

@@ -1,52 +0,0 @@
-import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http";
-import { ResponseError } from "@homarr/common/server";
-import type { IntegrationInput, IntegrationTestingInput } from "../base/integration";
-import { Integration } from "../base/integration";
-import { dawarichPlacesSchema, dawarichStatisticsSchema } from "./dawarich-schemas";
-import type { z } from "zod/v4";
-import type { TestingResult } from "../base/test-connection/test-connection-service";
-import { TestConnectionError } from "../base/test-connection/test-connection-error";
-
-export class DawarichIntegration extends Integration {
-  constructor(integration: IntegrationInput) {
-    super(integration);
-  }
-
-  protected async testingAsync(input: IntegrationTestingInput): Promise<TestingResult> {
-    const response = await fetchWithTrustedCertificatesAsync(this.url(`/api/v1/users/me`), {
-      headers: { Authorization: `Bearer ${this.getSecretValue("apiKey")}` },
-    });
-
-    if (response.status === 200) {
-      return { success: true };
-    }
-
-    return TestConnectionError.StatusResult(response);
-  }
-
-  async getStatisticsAsync(): Promise<{
-    totalDistanceKm: number;
-    totalPointsTracked: number;
-    totalReverseGeocodedPoints: number;
-    totalCountriesVisited: number;
-    totalCitiesVisited: number;
-  }> {
-    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/v1/stats"), {
-      headers: { Authorization: `Bearer ${this.getSecretValue("apiKey")}` },
-    });
-
-    if (!response.ok) throw new ResponseError(response);
-
-    return dawarichStatisticsSchema.parseAsync(await response.json());
-  }
-
-  async getPlacesAsync(): Promise<z.infer<typeof dawarichPlacesSchema>> {
-    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/v1/places"), {
-      headers: { Authorization: `Bearer ${this.getSecretValue("apiKey")}` },
-    });
-
-    if (!response.ok) throw new ResponseError(response);
-
-    return dawarichPlacesSchema.parseAsync(await response.json());
-  }
-}

packages/integrations/src/dawarich/dawarich-schemas.ts

@@ -1,31 +0,0 @@
-import { z } from "zod/v4";
-
-export const dawarichStatisticsSchema = z.object({
-  totalDistanceKm: z.number(),
-  totalPointsTracked: z.number(),
-  totalReverseGeocodedPoints: z.number(),
-  totalCountriesVisited: z.number(),
-  totalCitiesVisited: z.number(),
-});
-
-export const dawarichPlaceTagSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  icon: z.string(),
-  color: z.string(),
-});
-
-export const dawarichPlaceSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  latitude: z.number(),
-  longitude: z.number(),
-  source: z.string().optional(),
-  icon: z.string().nullable(),
-  color: z.string().nullable(),
-  visits_count: z.number(),
-  created_at: z.string(),
-  tags: z.array(dawarichPlaceTagSchema),
-});
-
-export const dawarichPlacesSchema = z.array(dawarichPlaceSchema);

packages/integrations/src/dawarich/dawarich-types.ts

@@ -1,5 +0,0 @@
-import type { z } from "zod/v4";
-import type { dawarichPlacesSchema, dawarichStatisticsSchema } from "./dawarich-schemas";
-
-export type DawarichStatistics = z.infer<typeof dawarichStatisticsSchema>;
-export type DawarichPlace = z.infer<typeof dawarichPlacesSchema>[number];

packages/integrations/src/index.ts

@@ -41,7 +41,6 @@ export { NavidromeIntegration } from "./navidrome/navidrome-integration";
 export { UptimeKumaIntegration } from "./uptime-kuma/uptime-kuma-integration";
 export { UmamiIntegration } from "./umami/umami-integration";
 export { PeaNutIntegration } from "./peanut/peanut-integration";
-export { DawarichIntegration } from "./dawarich/dawarich-integration";
 
 // Types
 export type { IntegrationInput } from "./base/integration";
@@ -87,7 +86,6 @@ export type { AudiobookshelfDashboardData } from "./audiobookshelf/audiobookshel
 export type { NavidromeDashboardData } from "./navidrome/navidrome-types";
 export type { UptimeKumaDashboardData } from "./uptime-kuma/uptime-kuma-types";
 export type { UmamiVisitorStats } from "./umami/umami-types";
-export type { DawarichStatistics, DawarichPlace } from "./dawarich/dawarich-types";
 
 // Schemas
 export { anchorNotesListInputSchema } from "./anchor/anchor-types";

packages/integrations/src/media-transcoding/fileflows-integration.ts

@@ -0,0 +1,200 @@
+import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http";
+
+import type { IntegrationTestingInput } from "../base/integration";
+import { Integration } from "../base/integration";
+import { TestConnectionError } from "../base/test-connection/test-connection-error";
+import type { TestingResult } from "../base/test-connection/test-connection-service";
+import type { IMediaTranscodingIntegration } from "../interfaces/media-transcoding/media-transcoding-integration";
+import type { TdarrQueue, TdarrStatistics, TdarrWorker } from "../interfaces/media-transcoding/media-transcoding-types";
+import {
+  libraryStatusSchema,
+  recentlyFinishedSchema,
+  shrinkageGroupsSchema,
+  statusResponseSchema,
+  upcomingFilesSchema,
+  workersResponseSchema,
+} from "./fileflows-validation-schemas";
+
+export class FileFlowsIntegration extends Integration implements IMediaTranscodingIntegration {
+  protected async testingAsync(input: IntegrationTestingInput): Promise<TestingResult> {
+    const response = await input.fetchAsync(this.url("/api/system/version"), {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        ...(super.hasSecretValue("apiKey") ? { "X-Api-Key": super.getSecretValue("apiKey") } : {}),
+      },
+    });
+
+    if (!response.ok) return TestConnectionError.StatusResult(response);
+
+    return { success: true };
+  }
+
+  public async getStatisticsAsync(): Promise<TdarrStatistics> {
+    const headerParams = {
+      accept: "application/json",
+      "Content-Type": "application/json",
+      ...(super.hasSecretValue("apiKey") ? { "X-Api-Key": super.getSecretValue("apiKey") } : {}),
+    };
+
+    const [statusData, libraryStatusData, shrinkageData] = await Promise.all([
+      this.fetchStatusAsync(headerParams),
+      this.fetchLibraryStatusAsync(headerParams),
+      this.fetchShrinkageAsync(headerParams),
+    ]);
+
+    const failedCount = libraryStatusData
+      .filter((item) => item.Status === 4)
+      .reduce((sum, item) => sum + item.Count, 0);
+    const processedCount = libraryStatusData
+      .filter((item) => item.Status === 3)
+      .reduce((sum, item) => sum + item.Count, 0);
+    const queuedCount = libraryStatusData
+      .filter((item) => item.Status === 1 || item.Status === 5)
+      .reduce((sum, item) => sum + item.Count, 0);
+
+    const totalSavedSpace = Object.values(shrinkageData).reduce(
+      (sum, group) => sum + Math.max(0, group.OriginalSize - group.FinalSize),
+      0,
+    );
+
+    const transcodeStatus = [
+      { name: "Processed", value: statusData.processed },
+      { name: "Queued", value: statusData.queue },
+      { name: "Processing", value: statusData.processing },
+      { name: "Failed", value: failedCount },
+    ];
+
+    return {
+      libraryName: "All",
+      totalFileCount: processedCount + queuedCount + statusData.processing + failedCount,
+      totalTranscodeCount: statusData.processed,
+      totalHealthCheckCount: 0,
+      failedTranscodeCount: failedCount,
+      failedHealthCheckCount: 0,
+      stagedTranscodeCount: statusData.queue,
+      stagedHealthCheckCount: 0,
+      totalSavedSpace,
+      transcodeStatus,
+      healthCheckStatus: [],
+      videoCodecs: [],
+      videoContainers: [],
+      videoResolutions: [],
+      audioCodecs: [],
+      audioContainers: [],
+    };
+  }
+
+  public async getWorkersAsync(): Promise<TdarrWorker[]> {
+    const headerParams = {
+      "Content-Type": "application/json",
+      ...(super.hasSecretValue("apiKey") ? { "X-Api-Key": super.getSecretValue("apiKey") } : {}),
+    };
+
+    const url = this.url("/api/worker");
+    const response = await fetchWithTrustedCertificatesAsync(url, {
+      method: "GET",
+      headers: headerParams,
+    });
+
+    const workersData = await workersResponseSchema.parseAsync(await response.json());
+
+    return workersData.map((worker) => ({
+      id: worker.Uid,
+      filePath: worker.RelativeFile ?? "",
+      fps: 0,
+      percentage: worker.CurrentPartPercent,
+      ETA: worker.ProcessingTime?.TotalSeconds ? `${Math.round(worker.ProcessingTime.TotalSeconds)}s` : "",
+      jobType: worker.CurrentPartName ?? "Processing",
+      status: "Processing",
+      step: worker.CurrentPartName ?? "",
+      originalSize: worker.LibraryFile?.OriginalSize ?? 0,
+      estimatedSize: null,
+      outputSize: null,
+    }));
+  }
+
+  public async getQueueAsync(firstItemIndex: number, pageSize: number): Promise<TdarrQueue> {
+    const headerParams = {
+      "Content-Type": "application/json",
+      ...(super.hasSecretValue("apiKey") ? { "X-Api-Key": super.getSecretValue("apiKey") } : {}),
+    };
+
+    const [upcomingItems, recentlyFinishedItems] = await Promise.all([
+      this.fetchUpcomingAsync(headerParams),
+      this.fetchRecentlyFinishedAsync(headerParams),
+    ]);
+
+    const queueArray = [
+      ...upcomingItems.map((item) => ({
+        id: item.Uid,
+        healthCheck: "",
+        transcode: item.Flow ?? "Default",
+        filePath: item.RelativePath ?? item.Name ?? "",
+        fileSize: item.OriginalSize ?? 0,
+        container: "",
+        codec: "",
+        resolution: "",
+        type: "transcode" as const,
+      })),
+      ...recentlyFinishedItems.map((item) => ({
+        id: item.Uid,
+        healthCheck: "",
+        transcode: item.Flow ?? "Default",
+        filePath: item.RelativePath ?? item.Name ?? "",
+        fileSize: item.FinalSize ?? item.OriginalSize ?? 0,
+        container: "",
+        codec: "",
+        resolution: "",
+        type: "health-check" as const,
+      })),
+    ].slice(0, pageSize);
+
+    return {
+      array: queueArray,
+      totalCount: upcomingItems.length + recentlyFinishedItems.length,
+      startIndex: firstItemIndex,
+      endIndex: firstItemIndex + queueArray.length - 1,
+    };
+  }
+
+  private async fetchStatusAsync(headerParams: Record<string, string>) {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/status"), {
+      method: "GET",
+      headers: headerParams,
+    });
+    return statusResponseSchema.parseAsync(await response.json());
+  }
+
+  private async fetchLibraryStatusAsync(headerParams: Record<string, string>) {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/library-file/status"), {
+      method: "GET",
+      headers: headerParams,
+    });
+    return libraryStatusSchema.parseAsync(await response.json());
+  }
+
+  private async fetchShrinkageAsync(headerParams: Record<string, string>) {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/library-file/shrinkage-groups"), {
+      method: "GET",
+      headers: headerParams,
+    });
+    return shrinkageGroupsSchema.parseAsync(await response.json());
+  }
+
+  private async fetchUpcomingAsync(headerParams: Record<string, string>) {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/library-file/upcoming"), {
+      method: "GET",
+      headers: headerParams,
+    });
+    return upcomingFilesSchema.parseAsync(await response.json());
+  }
+
+  private async fetchRecentlyFinishedAsync(headerParams: Record<string, string>) {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/library-file/recently-finished"), {
+      method: "GET",
+      headers: headerParams,
+    });
+    return recentlyFinishedSchema.parseAsync(await response.json());
+  }
+}

packages/integrations/src/media-transcoding/fileflows-validation-schemas.ts

@@ -0,0 +1,98 @@
+import { z } from "zod/v4";
+
+export const statusResponseSchema = z.object({
+  queue: z.number(),
+  processing: z.number(),
+  processed: z.number(),
+  processingFiles: z
+    .array(
+      z.object({
+        name: z.string().nullable(),
+        relativePath: z.string().nullable(),
+        library: z.string().nullable(),
+        step: z.string().nullable(),
+        stepPercent: z.number(),
+      }),
+    )
+    .optional()
+    .transform((arr) => arr ?? []),
+});
+
+export const libraryStatusSchema = z.array(
+  z.object({
+    Name: z.string().nullable(),
+    Status: z.number(),
+    Count: z.number(),
+  }),
+);
+
+export const shrinkageGroupsSchema = z.record(
+  z.string(),
+  z.object({
+    Library: z.string().nullable(),
+    OriginalSize: z.number(),
+    FinalSize: z.number(),
+    Items: z.number(),
+    Difference: z.number().optional(),
+  }),
+);
+
+export const workersResponseSchema = z.array(
+  z.object({
+    Uid: z.string(),
+    NodeName: z.string().nullable(),
+    RelativeFile: z.string().nullable(),
+    CurrentPart: z.number(),
+    CurrentPartName: z.string().nullable(),
+    CurrentPartPercent: z.number(),
+    StartedAt: z.string(),
+    LastUpdate: z.string(),
+    ProcessingTime: z
+      .object({
+        TotalSeconds: z.number().optional(),
+      })
+      .optional(),
+    LibraryFile: z
+      .object({
+        OriginalSize: z.number(),
+      })
+      .optional(),
+    Library: z
+      .object({
+        Name: z.string().nullable(),
+      })
+      .optional(),
+  }),
+);
+
+export const upcomingFilesSchema = z.array(
+  z.object({
+    Uid: z.string(),
+    Name: z.string().nullable(),
+    RelativePath: z.string().nullable(),
+    OriginalSize: z.number().nullable(),
+    FinalSize: z.number().nullable(),
+    Status: z.number(),
+    Library: z.string().nullable(),
+    Flow: z.string().nullable(),
+    Node: z.string().nullable(),
+    ProcessingTime: z
+      .object({
+        TotalSeconds: z.number().optional(),
+      })
+      .optional(),
+  }),
+);
+
+export const recentlyFinishedSchema = z.array(
+  z.object({
+    Uid: z.string(),
+    Name: z.string().nullable(),
+    RelativePath: z.string().nullable(),
+    OriginalSize: z.number().nullable(),
+    FinalSize: z.number().nullable(),
+    Status: z.number(),
+    Library: z.string().nullable(),
+    Flow: z.string().nullable(),
+  }),
+);

packages/integrations/src/types.ts

@@ -25,4 +25,3 @@ export * from "./paperless-ngx/paperless-ngx-types";
 export * from "./umami/umami-types";
 export * from "./gluetun/gluetun-types";
 export * from "./beszel/beszel-types";
-export * from "./dawarich/dawarich-types";

packages/request-handler/src/dawarich.ts

@@ -1,32 +0,0 @@
-import dayjs from "dayjs";
-
-import { createIntegrationAsync } from "@homarr/integrations";
-import type { DawarichPlace, DawarichStatistics } from "@homarr/integrations";
-
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
-
-export const dawarichStatisticsRequestHandler = createCachedIntegrationRequestHandler<
-  DawarichStatistics,
-  "dawarich",
-  Record<string, never>
->({
-  async requestAsync(integration) {
-    const instance = await createIntegrationAsync(integration);
-    return await instance.getStatisticsAsync();
-  },
-  cacheDuration: dayjs.duration(5, "minutes"),
-  queryKey: "dawarichStatistics",
-});
-
-export const dawarichPlacesRequestHandler = createCachedIntegrationRequestHandler<
-  DawarichPlace[],
-  "dawarich",
-  Record<string, never>
->({
-  async requestAsync(integration) {
-    const instance = await createIntegrationAsync(integration);
-    return await instance.getPlacesAsync();
-  },
-  cacheDuration: dayjs.duration(5, "minutes"),
-  queryKey: "dawarichPlaces",
-});

packages/translation/src/lang/en.json

@@ -3545,42 +3545,6 @@
       "executeSuccess": "Action executed successfully",
       "executeFailed": "Action failed. Check the widget configuration."
     },
-    "dawarichStatistics": {
-      "name": "Dawarich Statistics",
-      "description": "Display travel statistics from Dawarich",
-      "option": {
-        "showTotalDistance": {
-          "label": "Show total distance"
-        },
-        "showTotalPoints": {
-          "label": "Show total points tracked"
-        },
-        "showReverseGeocoded": {
-          "label": "Show reverse geocoded points"
-        },
-        "showCountries": {
-          "label": "Show countries visited"
-        },
-        "showCities": {
-          "label": "Show cities visited"
-        }
-      },
-      "totalDistance": "Total distance",
-      "totalPoints": "Points tracked",
-      "reverseGeocoded": "Reverse geocoded",
-      "countries": "Countries",
-      "cities": "Cities"
-    },
-    "dawarichPlaces": {
-      "name": "Dawarich Places",
-      "description": "Display recently visited places from Dawarich",
-      "option": {
-        "maxPlaces": {
-          "label": "Max places to show"
-        }
-      },
-      "visits": "visits"
-    },
     "beszelSystemTable": {
       "name": "Beszel Systems (Table)",
       "description": "Table view of all Beszel-monitored systems with sortable columns and status indicators",

packages/widgets/src/dawarich-places/component.module.css

@@ -1,10 +0,0 @@
-.placeItem {
-  padding: 8px 12px;
-  border-radius: var(--mantine-radius-sm);
-  background-color: light-dark(var(--mantine-color-gray-0), var(--mantine-color-dark-6));
-  transition: all 0.2s ease;
-
-  &:hover {
-    background-color: light-dark(var(--mantine-color-gray-1), var(--mantine-color-dark-5));
-  }
-}

packages/widgets/src/dawarich-places/component.tsx

@@ -1,40 +0,0 @@
-"use client";
-
-import { Anchor, Group, Stack, Text } from "@mantine/core";
-import { IconMapPin } from "@tabler/icons-react";
-
-import { clientApi } from "@homarr/api/client";
-import { useI18n } from "@homarr/translation/client";
-
-import { WidgetEmptyState } from "../common/empty-state";
-import type { WidgetComponentProps } from "../definition";
-import classes from "./component.module.css";
-
-export default function DawarichPlacesWidget({ integrationIds, options }: WidgetComponentProps<"dawarichPlaces">) {
-  const t = useI18n();
-  const { data: places } = clientApi.widget.dawarich.getPlaces.useQuery(
-    {
-      integrationId: integrationIds[0] ?? "",
-      limit: options.maxPlaces,
-    },
-    { staleTime: 5 * 60 * 1000 },
-  );
-
-  if (!places || places.length === 0) return <WidgetEmptyState />;
-
-  return (
-    <Stack gap="xs" h="100%" p="md">
-      {places.map((place) => (
-        <Group key={place.id} gap="sm" align="center" className={classes.placeItem}>
-          <IconMapPin size={16} />
-          <Text size="sm" fw={500} style={{ flex: 1 }}>
-            {place.name}
-          </Text>
-          <Text size="xs" c="dimmed">
-            {place.visits_count} {t("widget.dawarichPlaces.visits")}
-          </Text>
-        </Group>
-      ))}
-    </Stack>
-  );
-}

packages/widgets/src/dawarich-places/index.ts

@@ -1,16 +0,0 @@
-import { IconMapPin } from "@tabler/icons-react";
-import z from "zod";
-
-import { createWidgetDefinition } from "../definition";
-import { optionsBuilder } from "../options";
-
-export const { definition, componentLoader } = createWidgetDefinition("dawarichPlaces", {
-  icon: IconMapPin,
-  supportedIntegrations: ["dawarich"],
-  integrationsRequired: true,
-  createOptions() {
-    return optionsBuilder.from((factory) => ({
-      maxPlaces: factory.number({ defaultValue: 10, validate: z.number().min(1).max(50) }),
-    }));
-  },
-}).withDynamicImport(() => import("./component"));

packages/widgets/src/dawarich-statistics/component.module.css

@@ -1,10 +0,0 @@
-.statItem {
-  padding: 12px;
-  border-radius: var(--mantine-radius-md);
-  background-color: light-dark(var(--mantine-color-gray-0), var(--mantine-color-dark-6));
-  transition: all 0.2s ease;
-
-  &:hover {
-    background-color: light-dark(var(--mantine-color-gray-1), var(--mantine-color-dark-5));
-  }
-}

packages/widgets/src/dawarich-statistics/component.tsx

@@ -1,88 +0,0 @@
-"use client";
-
-import { Group, Stack, Text } from "@mantine/core";
-import { IconMap, IconMapPin, IconRoute, IconWorld, IconBuildingSkyscraper } from "@tabler/icons-react";
-
-import { clientApi } from "@homarr/api/client";
-import { useI18n } from "@homarr/translation/client";
-
-import { WidgetEmptyState } from "../common/empty-state";
-import type { WidgetComponentProps } from "../definition";
-import classes from "./component.module.css";
-
-export default function DawarichStatisticsWidget({
-  integrationIds,
-  options,
-}: WidgetComponentProps<"dawarichStatistics">) {
-  const t = useI18n();
-  const { data: stats } = clientApi.widget.dawarich.getStatistics.useQuery(
-    {
-      integrationId: integrationIds[0] ?? "",
-    },
-    { staleTime: 5 * 60 * 1000 },
-  );
-
-  if (!stats) return <WidgetEmptyState />;
-
-  return (
-    <Stack gap="md" h="100%" p="md">
-      {options.showTotalDistance && (
-        <StatItem
-          icon={<IconRoute size={20} />}
-          label={t("widget.dawarichStatistics.totalDistance")}
-          value={`${stats.totalDistanceKm.toLocaleString(undefined, { maximumFractionDigits: 1 })} km`}
-        />
-      )}
-      {options.showTotalPoints && (
-        <StatItem
-          icon={<IconMap size={20} />}
-          label={t("widget.dawarichStatistics.totalPoints")}
-          value={stats.totalPointsTracked.toLocaleString()}
-        />
-      )}
-      {options.showReverseGeocoded && (
-        <StatItem
-          icon={<IconMapPin size={20} />}
-          label={t("widget.dawarichStatistics.reverseGeocoded")}
-          value={stats.totalReverseGeocodedPoints.toLocaleString()}
-        />
-      )}
-      {options.showCountries && (
-        <StatItem
-          icon={<IconWorld size={20} />}
-          label={t("widget.dawarichStatistics.countries")}
-          value={stats.totalCountriesVisited.toLocaleString()}
-        />
-      )}
-      {options.showCities && (
-        <StatItem
-          icon={<IconBuildingSkyscraper size={20} />}
-          label={t("widget.dawarichStatistics.cities")}
-          value={stats.totalCitiesVisited.toLocaleString()}
-        />
-      )}
-    </Stack>
-  );
-}
-
-interface StatItemProps {
-  icon: React.ReactNode;
-  label: string;
-  value: string | number;
-}
-
-function StatItem({ icon, label, value }: StatItemProps) {
-  return (
-    <Group justify="space-between" align="center" className={classes.statItem}>
-      <Group gap="sm" align="center">
-        {icon}
-        <Text size="sm" fw={500}>
-          {label}
-        </Text>
-      </Group>
-      <Text size="sm" fw={700} c="var(--mantine-primary-color)">
-        {value}
-      </Text>
-    </Group>
-  );
-}

packages/widgets/src/dawarich-statistics/index.ts

@@ -1,19 +0,0 @@
-import { IconChartBar } from "@tabler/icons-react";
-
-import { createWidgetDefinition } from "../definition";
-import { optionsBuilder } from "../options";
-
-export const { definition, componentLoader } = createWidgetDefinition("dawarichStatistics", {
-  icon: IconChartBar,
-  supportedIntegrations: ["dawarich"],
-  integrationsRequired: true,
-  createOptions() {
-    return optionsBuilder.from((factory) => ({
-      showTotalDistance: factory.switch({ defaultValue: true }),
-      showTotalPoints: factory.switch({ defaultValue: true }),
-      showReverseGeocoded: factory.switch({ defaultValue: true }),
-      showCountries: factory.switch({ defaultValue: true }),
-      showCities: factory.switch({ defaultValue: true }),
-    }));
-  },
-}).withDynamicImport(() => import("./component"));

packages/widgets/src/index.tsx

@@ -60,8 +60,6 @@ import * as beszelSystemStats from "./beszel-system-stats";
 import * as video from "./video";
 import * as weather from "./weather";
 import * as customApi from "./custom-api";
-import * as dawarichStatistics from "./dawarich-statistics";
-import * as dawarichPlaces from "./dawarich-places";
 
 export type {
   WidgetDefinition,
@@ -123,8 +121,6 @@ export const widgetImports = {
   beszelAlerts,
   beszelSystemStats,
   customApi,
-  dawarichStatistics,
-  dawarichPlaces,
 } satisfies WidgetImportRecord;
 
 export type WidgetImports = typeof widgetImports;