return distance in response

mobile/openapi/README.md

@@ -341,6 +341,7 @@ Class | Method | HTTP request | Description
  - [AssetMetadataUpsertItemDto](doc//AssetMetadataUpsertItemDto.md)
  - [AssetOrder](doc//AssetOrder.md)
  - [AssetResponseDto](doc//AssetResponseDto.md)
+ - [AssetSearchResponseDto](doc//AssetSearchResponseDto.md)
  - [AssetStackResponseDto](doc//AssetStackResponseDto.md)
  - [AssetStatsResponseDto](doc//AssetStatsResponseDto.md)
  - [AssetTypeEnum](doc//AssetTypeEnum.md)

mobile/openapi/lib/api.dart

@@ -112,6 +112,7 @@ part 'model/asset_metadata_upsert_dto.dart';
 part 'model/asset_metadata_upsert_item_dto.dart';
 part 'model/asset_order.dart';
 part 'model/asset_response_dto.dart';
+part 'model/asset_search_response_dto.dart';
 part 'model/asset_stack_response_dto.dart';
 part 'model/asset_stats_response_dto.dart';
 part 'model/asset_type_enum.dart';

mobile/openapi/lib/api_client.dart

@@ -278,6 +278,8 @@ class ApiClient {
           return AssetOrderTypeTransformer().decode(value);
         case 'AssetResponseDto':
           return AssetResponseDto.fromJson(value);
+        case 'AssetSearchResponseDto':
+          return AssetSearchResponseDto.fromJson(value);
         case 'AssetStackResponseDto':
           return AssetStackResponseDto.fromJson(value);
         case 'AssetStatsResponseDto':

mobile/openapi/lib/model/asset_search_response_dto.dart

@@ -0,0 +1,421 @@
+//
+// AUTO-GENERATED FILE, DO NOT MODIFY!
+//
+// @dart=2.18
+
+// ignore_for_file: unused_element, unused_import
+// ignore_for_file: always_put_required_named_parameters_first
+// ignore_for_file: constant_identifier_names
+// ignore_for_file: lines_longer_than_80_chars
+
+part of openapi.api;
+
+class AssetSearchResponseDto {
+  /// Returns a new [AssetSearchResponseDto] instance.
+  AssetSearchResponseDto({
+    required this.checksum,
+    required this.createdAt,
+    required this.deviceAssetId,
+    required this.deviceId,
+    this.distance,
+    this.duplicateId,
+    required this.duration,
+    this.exifInfo,
+    required this.fileCreatedAt,
+    required this.fileModifiedAt,
+    required this.hasMetadata,
+    required this.id,
+    required this.isArchived,
+    required this.isFavorite,
+    required this.isOffline,
+    required this.isTrashed,
+    this.libraryId,
+    this.livePhotoVideoId,
+    required this.localDateTime,
+    required this.originalFileName,
+    this.originalMimeType,
+    required this.originalPath,
+    this.owner,
+    required this.ownerId,
+    this.people = const [],
+    this.resized,
+    this.stack,
+    this.tags = const [],
+    required this.thumbhash,
+    required this.type,
+    this.unassignedFaces = const [],
+    required this.updatedAt,
+    required this.visibility,
+  });
+
+  /// base64 encoded sha1 hash
+  String checksum;
+
+  /// The UTC timestamp when the asset was originally uploaded to Immich.
+  DateTime createdAt;
+
+  String deviceAssetId;
+
+  String deviceId;
+
+  ///
+  /// Please note: This property should have been non-nullable! Since the specification file
+  /// does not include a default value (using the "default:" property), however, the generated
+  /// source code must fall back to having a nullable type.
+  /// Consider adding a "default:" property in the specification file to hide this note.
+  ///
+  num? distance;
+
+  String? duplicateId;
+
+  String duration;
+
+  ///
+  /// Please note: This property should have been non-nullable! Since the specification file
+  /// does not include a default value (using the "default:" property), however, the generated
+  /// source code must fall back to having a nullable type.
+  /// Consider adding a "default:" property in the specification file to hide this note.
+  ///
+  ExifResponseDto? exifInfo;
+
+  /// The actual UTC timestamp when the file was created/captured, preserving timezone information. This is the authoritative timestamp for chronological sorting within timeline groups. Combined with timezone data, this can be used to determine the exact moment the photo was taken.
+  DateTime fileCreatedAt;
+
+  /// The UTC timestamp when the file was last modified on the filesystem. This reflects the last time the physical file was changed, which may be different from when the photo was originally taken.
+  DateTime fileModifiedAt;
+
+  bool hasMetadata;
+
+  String id;
+
+  bool isArchived;
+
+  bool isFavorite;
+
+  bool isOffline;
+
+  bool isTrashed;
+
+  /// This property was deprecated in v1.106.0
+  String? libraryId;
+
+  String? livePhotoVideoId;
+
+  /// The local date and time when the photo/video was taken, derived from EXIF metadata. This represents the photographer's local time regardless of timezone, stored as a timezone-agnostic timestamp. Used for timeline grouping by \"local\" days and months.
+  DateTime localDateTime;
+
+  String originalFileName;
+
+  ///
+  /// Please note: This property should have been non-nullable! Since the specification file
+  /// does not include a default value (using the "default:" property), however, the generated
+  /// source code must fall back to having a nullable type.
+  /// Consider adding a "default:" property in the specification file to hide this note.
+  ///
+  String? originalMimeType;
+
+  String originalPath;
+
+  ///
+  /// Please note: This property should have been non-nullable! Since the specification file
+  /// does not include a default value (using the "default:" property), however, the generated
+  /// source code must fall back to having a nullable type.
+  /// Consider adding a "default:" property in the specification file to hide this note.
+  ///
+  UserResponseDto? owner;
+
+  String ownerId;
+
+  List<PersonWithFacesResponseDto> people;
+
+  /// This property was deprecated in v1.113.0
+  ///
+  /// Please note: This property should have been non-nullable! Since the specification file
+  /// does not include a default value (using the "default:" property), however, the generated
+  /// source code must fall back to having a nullable type.
+  /// Consider adding a "default:" property in the specification file to hide this note.
+  ///
+  bool? resized;
+
+  AssetStackResponseDto? stack;
+
+  List<TagResponseDto> tags;
+
+  String? thumbhash;
+
+  AssetTypeEnum type;
+
+  List<AssetFaceWithoutPersonResponseDto> unassignedFaces;
+
+  /// The UTC timestamp when the asset record was last updated in the database. This is automatically maintained by the database and reflects when any field in the asset was last modified.
+  DateTime updatedAt;
+
+  AssetVisibility visibility;
+
+  @override
+  bool operator ==(Object other) => identical(this, other) || other is AssetSearchResponseDto &&
+    other.checksum == checksum &&
+    other.createdAt == createdAt &&
+    other.deviceAssetId == deviceAssetId &&
+    other.deviceId == deviceId &&
+    other.distance == distance &&
+    other.duplicateId == duplicateId &&
+    other.duration == duration &&
+    other.exifInfo == exifInfo &&
+    other.fileCreatedAt == fileCreatedAt &&
+    other.fileModifiedAt == fileModifiedAt &&
+    other.hasMetadata == hasMetadata &&
+    other.id == id &&
+    other.isArchived == isArchived &&
+    other.isFavorite == isFavorite &&
+    other.isOffline == isOffline &&
+    other.isTrashed == isTrashed &&
+    other.libraryId == libraryId &&
+    other.livePhotoVideoId == livePhotoVideoId &&
+    other.localDateTime == localDateTime &&
+    other.originalFileName == originalFileName &&
+    other.originalMimeType == originalMimeType &&
+    other.originalPath == originalPath &&
+    other.owner == owner &&
+    other.ownerId == ownerId &&
+    _deepEquality.equals(other.people, people) &&
+    other.resized == resized &&
+    other.stack == stack &&
+    _deepEquality.equals(other.tags, tags) &&
+    other.thumbhash == thumbhash &&
+    other.type == type &&
+    _deepEquality.equals(other.unassignedFaces, unassignedFaces) &&
+    other.updatedAt == updatedAt &&
+    other.visibility == visibility;
+
+  @override
+  int get hashCode =>
+    // ignore: unnecessary_parenthesis
+    (checksum.hashCode) +
+    (createdAt.hashCode) +
+    (deviceAssetId.hashCode) +
+    (deviceId.hashCode) +
+    (distance == null ? 0 : distance!.hashCode) +
+    (duplicateId == null ? 0 : duplicateId!.hashCode) +
+    (duration.hashCode) +
+    (exifInfo == null ? 0 : exifInfo!.hashCode) +
+    (fileCreatedAt.hashCode) +
+    (fileModifiedAt.hashCode) +
+    (hasMetadata.hashCode) +
+    (id.hashCode) +
+    (isArchived.hashCode) +
+    (isFavorite.hashCode) +
+    (isOffline.hashCode) +
+    (isTrashed.hashCode) +
+    (libraryId == null ? 0 : libraryId!.hashCode) +
+    (livePhotoVideoId == null ? 0 : livePhotoVideoId!.hashCode) +
+    (localDateTime.hashCode) +
+    (originalFileName.hashCode) +
+    (originalMimeType == null ? 0 : originalMimeType!.hashCode) +
+    (originalPath.hashCode) +
+    (owner == null ? 0 : owner!.hashCode) +
+    (ownerId.hashCode) +
+    (people.hashCode) +
+    (resized == null ? 0 : resized!.hashCode) +
+    (stack == null ? 0 : stack!.hashCode) +
+    (tags.hashCode) +
+    (thumbhash == null ? 0 : thumbhash!.hashCode) +
+    (type.hashCode) +
+    (unassignedFaces.hashCode) +
+    (updatedAt.hashCode) +
+    (visibility.hashCode);
+
+  @override
+  String toString() => 'AssetSearchResponseDto[checksum=$checksum, createdAt=$createdAt, deviceAssetId=$deviceAssetId, deviceId=$deviceId, distance=$distance, duplicateId=$duplicateId, duration=$duration, exifInfo=$exifInfo, fileCreatedAt=$fileCreatedAt, fileModifiedAt=$fileModifiedAt, hasMetadata=$hasMetadata, id=$id, isArchived=$isArchived, isFavorite=$isFavorite, isOffline=$isOffline, isTrashed=$isTrashed, libraryId=$libraryId, livePhotoVideoId=$livePhotoVideoId, localDateTime=$localDateTime, originalFileName=$originalFileName, originalMimeType=$originalMimeType, originalPath=$originalPath, owner=$owner, ownerId=$ownerId, people=$people, resized=$resized, stack=$stack, tags=$tags, thumbhash=$thumbhash, type=$type, unassignedFaces=$unassignedFaces, updatedAt=$updatedAt, visibility=$visibility]';
+
+  Map<String, dynamic> toJson() {
+    final json = <String, dynamic>{};
+      json[r'checksum'] = this.checksum;
+      json[r'createdAt'] = this.createdAt.toUtc().toIso8601String();
+      json[r'deviceAssetId'] = this.deviceAssetId;
+      json[r'deviceId'] = this.deviceId;
+    if (this.distance != null) {
+      json[r'distance'] = this.distance;
+    } else {
+    //  json[r'distance'] = null;
+    }
+    if (this.duplicateId != null) {
+      json[r'duplicateId'] = this.duplicateId;
+    } else {
+    //  json[r'duplicateId'] = null;
+    }
+      json[r'duration'] = this.duration;
+    if (this.exifInfo != null) {
+      json[r'exifInfo'] = this.exifInfo;
+    } else {
+    //  json[r'exifInfo'] = null;
+    }
+      json[r'fileCreatedAt'] = this.fileCreatedAt.toUtc().toIso8601String();
+      json[r'fileModifiedAt'] = this.fileModifiedAt.toUtc().toIso8601String();
+      json[r'hasMetadata'] = this.hasMetadata;
+      json[r'id'] = this.id;
+      json[r'isArchived'] = this.isArchived;
+      json[r'isFavorite'] = this.isFavorite;
+      json[r'isOffline'] = this.isOffline;
+      json[r'isTrashed'] = this.isTrashed;
+    if (this.libraryId != null) {
+      json[r'libraryId'] = this.libraryId;
+    } else {
+    //  json[r'libraryId'] = null;
+    }
+    if (this.livePhotoVideoId != null) {
+      json[r'livePhotoVideoId'] = this.livePhotoVideoId;
+    } else {
+    //  json[r'livePhotoVideoId'] = null;
+    }
+      json[r'localDateTime'] = this.localDateTime.toUtc().toIso8601String();
+      json[r'originalFileName'] = this.originalFileName;
+    if (this.originalMimeType != null) {
+      json[r'originalMimeType'] = this.originalMimeType;
+    } else {
+    //  json[r'originalMimeType'] = null;
+    }
+      json[r'originalPath'] = this.originalPath;
+    if (this.owner != null) {
+      json[r'owner'] = this.owner;
+    } else {
+    //  json[r'owner'] = null;
+    }
+      json[r'ownerId'] = this.ownerId;
+      json[r'people'] = this.people;
+    if (this.resized != null) {
+      json[r'resized'] = this.resized;
+    } else {
+    //  json[r'resized'] = null;
+    }
+    if (this.stack != null) {
+      json[r'stack'] = this.stack;
+    } else {
+    //  json[r'stack'] = null;
+    }
+      json[r'tags'] = this.tags;
+    if (this.thumbhash != null) {
+      json[r'thumbhash'] = this.thumbhash;
+    } else {
+    //  json[r'thumbhash'] = null;
+    }
+      json[r'type'] = this.type;
+      json[r'unassignedFaces'] = this.unassignedFaces;
+      json[r'updatedAt'] = this.updatedAt.toUtc().toIso8601String();
+      json[r'visibility'] = this.visibility;
+    return json;
+  }
+
+  /// Returns a new [AssetSearchResponseDto] instance and imports its values from
+  /// [value] if it's a [Map], null otherwise.
+  // ignore: prefer_constructors_over_static_methods
+  static AssetSearchResponseDto? fromJson(dynamic value) {
+    upgradeDto(value, "AssetSearchResponseDto");
+    if (value is Map) {
+      final json = value.cast<String, dynamic>();
+
+      return AssetSearchResponseDto(
+        checksum: mapValueOfType<String>(json, r'checksum')!,
+        createdAt: mapDateTime(json, r'createdAt', r'')!,
+        deviceAssetId: mapValueOfType<String>(json, r'deviceAssetId')!,
+        deviceId: mapValueOfType<String>(json, r'deviceId')!,
+        distance: num.parse('${json[r'distance']}'),
+        duplicateId: mapValueOfType<String>(json, r'duplicateId'),
+        duration: mapValueOfType<String>(json, r'duration')!,
+        exifInfo: ExifResponseDto.fromJson(json[r'exifInfo']),
+        fileCreatedAt: mapDateTime(json, r'fileCreatedAt', r'')!,
+        fileModifiedAt: mapDateTime(json, r'fileModifiedAt', r'')!,
+        hasMetadata: mapValueOfType<bool>(json, r'hasMetadata')!,
+        id: mapValueOfType<String>(json, r'id')!,
+        isArchived: mapValueOfType<bool>(json, r'isArchived')!,
+        isFavorite: mapValueOfType<bool>(json, r'isFavorite')!,
+        isOffline: mapValueOfType<bool>(json, r'isOffline')!,
+        isTrashed: mapValueOfType<bool>(json, r'isTrashed')!,
+        libraryId: mapValueOfType<String>(json, r'libraryId'),
+        livePhotoVideoId: mapValueOfType<String>(json, r'livePhotoVideoId'),
+        localDateTime: mapDateTime(json, r'localDateTime', r'')!,
+        originalFileName: mapValueOfType<String>(json, r'originalFileName')!,
+        originalMimeType: mapValueOfType<String>(json, r'originalMimeType'),
+        originalPath: mapValueOfType<String>(json, r'originalPath')!,
+        owner: UserResponseDto.fromJson(json[r'owner']),
+        ownerId: mapValueOfType<String>(json, r'ownerId')!,
+        people: PersonWithFacesResponseDto.listFromJson(json[r'people']),
+        resized: mapValueOfType<bool>(json, r'resized'),
+        stack: AssetStackResponseDto.fromJson(json[r'stack']),
+        tags: TagResponseDto.listFromJson(json[r'tags']),
+        thumbhash: mapValueOfType<String>(json, r'thumbhash'),
+        type: AssetTypeEnum.fromJson(json[r'type'])!,
+        unassignedFaces: AssetFaceWithoutPersonResponseDto.listFromJson(json[r'unassignedFaces']),
+        updatedAt: mapDateTime(json, r'updatedAt', r'')!,
+        visibility: AssetVisibility.fromJson(json[r'visibility'])!,
+      );
+    }
+    return null;
+  }
+
+  static List<AssetSearchResponseDto> listFromJson(dynamic json, {bool growable = false,}) {
+    final result = <AssetSearchResponseDto>[];
+    if (json is List && json.isNotEmpty) {
+      for (final row in json) {
+        final value = AssetSearchResponseDto.fromJson(row);
+        if (value != null) {
+          result.add(value);
+        }
+      }
+    }
+    return result.toList(growable: growable);
+  }
+
+  static Map<String, AssetSearchResponseDto> mapFromJson(dynamic json) {
+    final map = <String, AssetSearchResponseDto>{};
+    if (json is Map && json.isNotEmpty) {
+      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
+      for (final entry in json.entries) {
+        final value = AssetSearchResponseDto.fromJson(entry.value);
+        if (value != null) {
+          map[entry.key] = value;
+        }
+      }
+    }
+    return map;
+  }
+
+  // maps a json object with a list of AssetSearchResponseDto-objects as value to a dart map
+  static Map<String, List<AssetSearchResponseDto>> mapListFromJson(dynamic json, {bool growable = false,}) {
+    final map = <String, List<AssetSearchResponseDto>>{};
+    if (json is Map && json.isNotEmpty) {
+      // ignore: parameter_assignments
+      json = json.cast<String, dynamic>();
+      for (final entry in json.entries) {
+        map[entry.key] = AssetSearchResponseDto.listFromJson(entry.value, growable: growable,);
+      }
+    }
+    return map;
+  }
+
+  /// The list of required keys that must be present in a JSON.
+  static const requiredKeys = <String>{
+    'checksum',
+    'createdAt',
+    'deviceAssetId',
+    'deviceId',
+    'duration',
+    'fileCreatedAt',
+    'fileModifiedAt',
+    'hasMetadata',
+    'id',
+    'isArchived',
+    'isFavorite',
+    'isOffline',
+    'isTrashed',
+    'localDateTime',
+    'originalFileName',
+    'originalPath',
+    'ownerId',
+    'thumbhash',
+    'type',
+    'updatedAt',
+    'visibility',
+  };
+}
+

mobile/openapi/lib/model/search_asset_response_dto.dart

@@ -24,7 +24,7 @@ class SearchAssetResponseDto {
 
   List<SearchFacetResponseDto> facets;
 
-  List<AssetResponseDto> items;
+  List<AssetSearchResponseDto> items;
 
   String? nextPage;
 
@@ -75,7 +75,7 @@ class SearchAssetResponseDto {
       return SearchAssetResponseDto(
         count: mapValueOfType<int>(json, r'count')!,
         facets: SearchFacetResponseDto.listFromJson(json[r'facets']),
-        items: AssetResponseDto.listFromJson(json[r'items']),
+        items: AssetSearchResponseDto.listFromJson(json[r'items']),
         nextPage: mapValueOfType<String>(json, r'nextPage'),
         total: mapValueOfType<int>(json, r'total')!,
       );

open-api/immich-openapi-specs.json

@@ -11220,6 +11220,179 @@
         ],
         "type": "object"
       },
+      "AssetSearchResponseDto": {
+        "properties": {
+          "checksum": {
+            "description": "base64 encoded sha1 hash",
+            "type": "string"
+          },
+          "createdAt": {
+            "description": "The UTC timestamp when the asset was originally uploaded to Immich.",
+            "example": "2024-01-15T20:30:00.000Z",
+            "format": "date-time",
+            "type": "string"
+          },
+          "deviceAssetId": {
+            "type": "string"
+          },
+          "deviceId": {
+            "type": "string"
+          },
+          "distance": {
+            "type": "number"
+          },
+          "duplicateId": {
+            "nullable": true,
+            "type": "string"
+          },
+          "duration": {
+            "type": "string"
+          },
+          "exifInfo": {
+            "$ref": "#/components/schemas/ExifResponseDto"
+          },
+          "fileCreatedAt": {
+            "description": "The actual UTC timestamp when the file was created/captured, preserving timezone information. This is the authoritative timestamp for chronological sorting within timeline groups. Combined with timezone data, this can be used to determine the exact moment the photo was taken.",
+            "example": "2024-01-15T19:30:00.000Z",
+            "format": "date-time",
+            "type": "string"
+          },
+          "fileModifiedAt": {
+            "description": "The UTC timestamp when the file was last modified on the filesystem. This reflects the last time the physical file was changed, which may be different from when the photo was originally taken.",
+            "example": "2024-01-16T10:15:00.000Z",
+            "format": "date-time",
+            "type": "string"
+          },
+          "hasMetadata": {
+            "type": "boolean"
+          },
+          "id": {
+            "type": "string"
+          },
+          "isArchived": {
+            "type": "boolean"
+          },
+          "isFavorite": {
+            "type": "boolean"
+          },
+          "isOffline": {
+            "type": "boolean"
+          },
+          "isTrashed": {
+            "type": "boolean"
+          },
+          "libraryId": {
+            "deprecated": true,
+            "description": "This property was deprecated in v1.106.0",
+            "nullable": true,
+            "type": "string"
+          },
+          "livePhotoVideoId": {
+            "nullable": true,
+            "type": "string"
+          },
+          "localDateTime": {
+            "description": "The local date and time when the photo/video was taken, derived from EXIF metadata. This represents the photographer's local time regardless of timezone, stored as a timezone-agnostic timestamp. Used for timeline grouping by \"local\" days and months.",
+            "example": "2024-01-15T14:30:00.000Z",
+            "format": "date-time",
+            "type": "string"
+          },
+          "originalFileName": {
+            "type": "string"
+          },
+          "originalMimeType": {
+            "type": "string"
+          },
+          "originalPath": {
+            "type": "string"
+          },
+          "owner": {
+            "$ref": "#/components/schemas/UserResponseDto"
+          },
+          "ownerId": {
+            "type": "string"
+          },
+          "people": {
+            "items": {
+              "$ref": "#/components/schemas/PersonWithFacesResponseDto"
+            },
+            "type": "array"
+          },
+          "resized": {
+            "deprecated": true,
+            "description": "This property was deprecated in v1.113.0",
+            "type": "boolean"
+          },
+          "stack": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/AssetStackResponseDto"
+              }
+            ],
+            "nullable": true
+          },
+          "tags": {
+            "items": {
+              "$ref": "#/components/schemas/TagResponseDto"
+            },
+            "type": "array"
+          },
+          "thumbhash": {
+            "nullable": true,
+            "type": "string"
+          },
+          "type": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/AssetTypeEnum"
+              }
+            ]
+          },
+          "unassignedFaces": {
+            "items": {
+              "$ref": "#/components/schemas/AssetFaceWithoutPersonResponseDto"
+            },
+            "type": "array"
+          },
+          "updatedAt": {
+            "description": "The UTC timestamp when the asset record was last updated in the database. This is automatically maintained by the database and reflects when any field in the asset was last modified.",
+            "example": "2024-01-16T12:45:30.000Z",
+            "format": "date-time",
+            "type": "string"
+          },
+          "visibility": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/AssetVisibility"
+              }
+            ]
+          }
+        },
+        "required": [
+          "checksum",
+          "createdAt",
+          "deviceAssetId",
+          "deviceId",
+          "duration",
+          "fileCreatedAt",
+          "fileModifiedAt",
+          "hasMetadata",
+          "id",
+          "isArchived",
+          "isFavorite",
+          "isOffline",
+          "isTrashed",
+          "localDateTime",
+          "originalFileName",
+          "originalPath",
+          "ownerId",
+          "thumbhash",
+          "type",
+          "updatedAt",
+          "visibility"
+        ],
+        "type": "object"
+      },
       "AssetStackResponseDto": {
         "properties": {
           "assetCount": {
@@ -13750,7 +13923,7 @@
           },
           "items": {
             "items": {
-              "$ref": "#/components/schemas/AssetResponseDto"
+              "$ref": "#/components/schemas/AssetSearchResponseDto"
             },
             "type": "array"
           },

open-api/typescript-sdk/src/fetch-client.ts

@@ -946,10 +946,53 @@ export type SearchAlbumResponseDto = {
     items: AlbumResponseDto[];
     total: number;
 };
+export type AssetSearchResponseDto = {
+    /** base64 encoded sha1 hash */
+    checksum: string;
+    /** The UTC timestamp when the asset was originally uploaded to Immich. */
+    createdAt: string;
+    deviceAssetId: string;
+    deviceId: string;
+    distance?: number;
+    duplicateId?: string | null;
+    duration: string;
+    exifInfo?: ExifResponseDto;
+    /** The actual UTC timestamp when the file was created/captured, preserving timezone information. This is the authoritative timestamp for chronological sorting within timeline groups. Combined with timezone data, this can be used to determine the exact moment the photo was taken. */
+    fileCreatedAt: string;
+    /** The UTC timestamp when the file was last modified on the filesystem. This reflects the last time the physical file was changed, which may be different from when the photo was originally taken. */
+    fileModifiedAt: string;
+    hasMetadata: boolean;
+    id: string;
+    isArchived: boolean;
+    isFavorite: boolean;
+    isOffline: boolean;
+    isTrashed: boolean;
+    /** This property was deprecated in v1.106.0 */
+    libraryId?: string | null;
+    livePhotoVideoId?: string | null;
+    /** The local date and time when the photo/video was taken, derived from EXIF metadata. This represents the photographer's local time regardless of timezone, stored as a timezone-agnostic timestamp. Used for timeline grouping by "local" days and months. */
+    localDateTime: string;
+    originalFileName: string;
+    originalMimeType?: string;
+    originalPath: string;
+    owner?: UserResponseDto;
+    ownerId: string;
+    people?: PersonWithFacesResponseDto[];
+    /** This property was deprecated in v1.113.0 */
+    resized?: boolean;
+    stack?: (AssetStackResponseDto) | null;
+    tags?: TagResponseDto[];
+    thumbhash: string | null;
+    "type": AssetTypeEnum;
+    unassignedFaces?: AssetFaceWithoutPersonResponseDto[];
+    /** The UTC timestamp when the asset record was last updated in the database. This is automatically maintained by the database and reflects when any field in the asset was last modified. */
+    updatedAt: string;
+    visibility: AssetVisibility;
+};
 export type SearchAssetResponseDto = {
     count: number;
     facets: SearchFacetResponseDto[];
-    items: AssetResponseDto[];
+    items: AssetSearchResponseDto[];
     nextPage: string | null;
     total: number;
 };

server/src/dtos/asset-response.dto.ts

@@ -130,6 +130,7 @@ export type MapAsset = {
   tags?: Tag[];
   thumbhash: Buffer<ArrayBufferLike> | null;
   type: AssetType;
+  distance?: number;
 };
 
 export class AssetStackResponseDto {

server/src/dtos/search.dto.ts

@@ -296,12 +296,16 @@ class SearchAlbumResponseDto {
   facets!: SearchFacetResponseDto[];
 }
 
+class AssetSearchResponseDto extends AssetResponseDto {
+  distance?: number;
+}
+
 class SearchAssetResponseDto {
   @ApiProperty({ type: 'integer' })
   total!: number;
   @ApiProperty({ type: 'integer' })
   count!: number;
-  items!: AssetResponseDto[];
+  items!: AssetSearchResponseDto[];
   facets!: SearchFacetResponseDto[];
   nextPage!: string | null;
 }

server/src/repositories/search.repository.ts

@@ -284,8 +284,9 @@ export class SearchRepository {
       await sql`set local vchordrq.probes = ${sql.lit(probes[VectorIndex.Clip])}`.execute(trx);
       const items = await searchAssetBuilder(trx, options)
         .selectAll('asset')
+        .select(sql<number>`smart_search.embedding <=> ${options.embedding}`.as('distance'))
         .innerJoin('smart_search', 'asset.id', 'smart_search.assetId')
-        .orderBy(sql`smart_search.embedding <=> ${options.embedding}`)
+        .orderBy('distance')
         .limit(pagination.size + 1)
         .offset((pagination.page - 1) * pagination.size)
         .execute();

server/src/services/search.service.ts

@@ -198,7 +198,7 @@ export class SearchService extends BaseService {
       assets: {
         total: assets.length,
         count: assets.length,
-        items: assets.map((asset) => mapAsset(asset, options)),
+        items: assets.map((asset) => ({ ...mapAsset(asset, options), distance: asset.distance })),
         facets: [],
         nextPage,
       },