replace any types with AT Protocol interfaces

Optimization #9:
- created atproto.types.ts with proper AT Protocol interfaces
- replaced 7 any types in batch-search-actors.ts
- added ATProtoActor, ATProtoProfile, RankedActor, EnrichedActor types
- improves type safety, compile-time error catching, IDE support

netlify/functions/batch-search-actors.ts

···
-import { AuthenticatedHandler } from "./core/types";
+import {
+  AuthenticatedHandler,
+  ATProtoActor,
+  ATProtoProfile,
+  RankedActor,
+  EnrichedActor,
+} from "./core/types";
 import { SessionService } from "./services/SessionService";
 import { successResponse, validateArrayInput, ValidationSchemas } from "./utils";
 import { withAuthErrorHandling } from "./core/middleware";
···
       const normalizedUsername = normalize(username);
 
       const rankedActors = response.data.actors
-        .map((actor: any) => {
+        .map((actor: ATProtoActor): RankedActor => {
           const handlePart = actor.handle.split(".")[0];
           const normalizedHandle = normalize(handlePart);
           const normalizedFullHandle = normalize(actor.handle);
···
             did: actor.did,
           };
         })
-        .filter((actor: any) => actor.matchScore > 0)
-        .sort((a: any, b: any) => b.matchScore - a.matchScore)
+        .filter((actor: RankedActor) => actor.matchScore > 0)
+        .sort((a: RankedActor, b: RankedActor) => b.matchScore - a.matchScore)
         .slice(0, 5);
 
       return {
···
   const results = await Promise.all(searchPromises);
 
   const allDids = results
-    .flatMap((r) => r.actors.map((a: any) => a.did))
+    .flatMap((r) => r.actors.map((a: RankedActor) => a.did))
     .filter((did): did is string => !!did);
 
   if (allDids.length > 0) {
···
           actors: batch,
         });
 
-        profilesResponse.data.profiles.forEach((profile: any) => {
+        profilesResponse.data.profiles.forEach((profile: ATProtoProfile) => {
           profileDataMap.set(profile.did, {
             postCount: profile.postsCount || 0,
             followerCount: profile.followersCount || 0,
···
     }
 
     results.forEach((result) => {
-      result.actors = result.actors.map((actor: any) => {
+      result.actors = result.actors.map((actor: RankedActor): EnrichedActor => {
         const enrichedData = profileDataMap.get(actor.did);
         return {
           ...actor,
···
       );
 
       results.forEach((result) => {
-        result.actors = result.actors.map((actor: any) => ({
+        result.actors = result.actors.map((actor: EnrichedActor): EnrichedActor => ({
           ...actor,
           followStatus: {
             [followLexicon]: followStatus[actor.did] || false,

netlify/functions/core/types/atproto.types.ts

···
+/**
+ * AT Protocol type definitions
+ * Based on @atproto/api response schemas
+ */
+
+/**
+ * Actor profile from app.bsky.actor.searchActors
+ */
+export interface ATProtoActor {
+  did: string;
+  handle: string;
+  displayName?: string;
+  avatar?: string;
+  description?: string;
+  indexedAt?: string;
+  labels?: any[]; // Moderation labels
+}
+
+/**
+ * Detailed profile from app.bsky.actor.getProfiles
+ */
+export interface ATProtoProfile {
+  did: string;
+  handle: string;
+  displayName?: string;
+  avatar?: string;
+  description?: string;
+  followersCount?: number;
+  followsCount?: number;
+  postsCount?: number;
+  indexedAt?: string;
+  labels?: any[];
+}
+
+/**
+ * Actor with match score (search result)
+ */
+export interface RankedActor extends ATProtoActor {
+  matchScore: number;
+}
+
+/**
+ * Enriched actor with profile data and follow status
+ */
+export interface EnrichedActor extends RankedActor {
+  postCount: number;
+  followerCount: number;
+  followStatus?: Record<string, boolean>;
+}
+
+/**
+ * Search actors response
+ */
+export interface SearchActorsResponse {
+  actors: ATProtoActor[];
+  cursor?: string;
+}
+
+/**
+ * Get profiles response
+ */
+export interface GetProfilesResponse {
+  profiles: ATProtoProfile[];
+}

netlify/functions/core/types/index.ts

···
 export * from "./database.types";
 export * from "./api.types";
+export * from "./atproto.types";