refactor(tests): enable noImplicitAny and annotate implicit-any sites

Flips \`noImplicitAny: true\` in \`tsconfig.test.json\` (removes the
override — now inherited from the base config) and fixes the ~630
resulting errors across ~20 test files. All annotations use SDK types
from \`stream-chat\` where applicable; \`as unknown as T\` casts reserved
for spots where the SDK type doesn't fit cleanly at the test boundary.

Patterns applied:
- \`let client\`, \`let channel\`, \`let chatClient\` → \`StreamChat\` /
  \`Channel\` / \`StreamChat\`.
- \`renderComponent\` / \`Wrapper\` / \`renderMessage\` helper signatures
  typed via \`ComponentProps<typeof X>\`, \`Partial<ChannelProps>\`,
  \`ComponentOverrides\`, or \`PropsWithChildren<Partial<...>>\`.
- Context-consumer arrows (\`({ fn }) => ...\`) typed with
  \`ChatContextValue\` / \`TranslationContextValue\`.
- Translation \`obj[key]\` → \`obj[key as keyof typeof obj]\`.
- Uninitialized locals typed with a definite-assigned cast
  (\`{} as ChatContextValue\`) to match the established pattern.
- \`_fiber\` and \`offlineDb.syncManager.invokeSyncStatusListeners\`
  accesses handled through narrow local shim types (\`TestOfflineDb\`,
  \`TestSyncManager\`) rather than widening the real SDK types.
- \`updatedMessage\` \`Array.find\` results narrowed with \`!\` at
  assertion sites.

Notable scope decisions (kept out of scope):
- \`Channel\`'s \`doUpdateMessageRequest\` callback signature mismatches
  the SDK — cast the arg to \`Awaited<ReturnType<typeof
  channel.messageComposer.compose>>\` at the mock site to preserve
  runtime behavior.
- \`messageComposer.compose\` mock resolves with \`{ localMessage,
  message }\` (no \`options\`) — dropped the dead \`options\` key; the
  SDK's \`MessageComposerMiddlewareState\` doesn't include it.
- Removed unused \`TestWsConnection\` type in \`offline-feature.tsx\`
  and the unused \`MessageInputContextValue\` / \`MessagesContextValue\`
  type-imports in \`optimistic-update.tsx\` to satisfy
  \`@typescript-eslint/no-unused-vars\`.

test:typecheck: 636 → 0. Full test suite: same pre-existing
SQLite-isolation flake in \`offline-support/index.test.ts\`; no
regressions. \`yarn lint\` / \`yarn build\` clean.

Closes #3563.

Author: oliverlaz

package/src/__tests__/offline-support/offline-feature.tsx

@@ -4,10 +4,13 @@ import { View } from 'react-native';
 import { act, cleanup, render, screen, waitFor } from '@testing-library/react-native';
 
 import type {
+  Channel as ChannelLLC,
   ChannelAPIResponse,
   ChannelMemberResponse,
   LocalMessage,
   ReactionResponse,
+  StreamChat,
+  UserResponse,
 } from 'stream-chat';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -41,13 +44,40 @@ const Channel = ChannelRaw as unknown as React.ComponentType<
   React.ComponentProps<typeof ChannelRaw> & { initialValue?: string }
 >;
 
+// Tests reach into internal / private StreamChat + LLC Channel APIs (sync manager, legacy
+// `wsConnection`, `_deleteMessage`, `_sendReaction`, `_sendMessage`). Helpers narrow at the
+// call sites without sprinkling `any` everywhere.
+type TestPendingTask = { id: number; type: string; payload: unknown };
+type TestSyncManager = {
+  invokeSyncStatusListeners: (recovered: boolean) => Promise<void>;
+};
+// Intentionally not intersected with the real `StreamChat['offlineDb']` — the
+// real `syncManager` member is a class with `invokeSyncStatusListeners` marked
+// private, which conflicts with the test-only accessor. Kept as a standalone
+// test shim shape.
+type TestOfflineDb = {
+  addPendingTask: (task: {
+    channelId: string | undefined;
+    channelType: string;
+    messageId: string;
+    payload: unknown;
+    type: string;
+  }) => Promise<void>;
+  deletePendingTask: (params: { id: number }) => Promise<void>;
+  getPendingTasks: () => Promise<TestPendingTask[]>;
+  syncManager: TestSyncManager;
+};
+const getOfflineDb = (client: StreamChat): TestOfflineDb =>
+  client.offlineDb as unknown as TestOfflineDb;
+
 test('Workaround to allow exporting tests', () => expect(true).toBe(true));
 
 export const OptimisticUpdates = () => {
   describe('Optimistic Updates', () => {
-    let chatClient;
+    let chatClient: StreamChat;
 
-    const getRandomInt = (lower, upper) => Math.floor(lower + Math.random() * (upper - lower + 1));
+    const getRandomInt = (lower: number, upper: number) =>
+      Math.floor(lower + Math.random() * (upper - lower + 1));
     const createChannel = () => {
       const allUsers = Array(20).fill(1).map(generateUser);
       const allMessages: LocalMessage[] = [];
@@ -63,7 +93,7 @@ export const OptimisticUpdates = () => {
       const begin = getRandomInt(0, allUsers.length - 2); // begin shouldn't be the end of users.length
       const end = getRandomInt(begin + 1, allUsers.length - 1);
       const usersForMembers = allUsers.slice(begin, end);
-      const members = usersForMembers.map((user) =>
+      const members = usersForMembers.map((user: UserResponse) =>
         generateMember({
           user,
         }),
@@ -78,7 +108,7 @@ export const OptimisticUpdates = () => {
           const end = getRandomInt(begin + 1, usersForMembers.length - 1);
 
           const usersForReactions = usersForMembers.slice(begin, end);
-          const reactions = usersForReactions.map((user) =>
+          const reactions = usersForReactions.map((user: UserResponse) =>
             generateReaction({
               message_id: id,
               user,
@@ -94,7 +124,7 @@ export const OptimisticUpdates = () => {
           });
         });
 
-      const reads = members.map((member) => ({
+      const reads = members.map((member: ChannelMemberResponse) => ({
         last_read: new Date(new Date().setDate(new Date().getDate() - getRandomInt(0, 20))),
         unread_messages: getRandomInt(0, messages.length),
         user: member.user,
@@ -136,7 +166,10 @@ export const OptimisticUpdates = () => {
         channels: [channelResponse] as unknown as ChannelAPIResponse[],
         isLatestMessagesSet: true,
       });
-      chatClient.wsConnection = { isHealthy: true, onlineStatusChanged: jest.fn() };
+      chatClient.wsConnection = {
+        isHealthy: true,
+        onlineStatusChanged: jest.fn(),
+      } as unknown as StreamChat['wsConnection'];
     });
 
     afterEach(() => {
@@ -146,11 +179,19 @@ export const OptimisticUpdates = () => {
       jest.clearAllMocks();
     });
 
-    let channel;
+    let channel: ChannelLLC;
     // This component is used for performing effects in a component that consumes ChannelContext,
     // i.e. making use of the callbacks & values provided by the Channel component.
     // the effect is called every time channelContext changes
-    const CallbackEffectWithContext = ({ callback, children, context }) => {
+    const CallbackEffectWithContext = <T,>({
+      callback,
+      children,
+      context,
+    }: {
+      callback: (ctx: T) => Promise<void> | void;
+      children: React.ReactNode;
+      context: React.Context<T>;
+    }) => {
       const ctx = useContext(context);
       const [ready, setReady] = useState(false);
       useEffect(() => {
@@ -166,7 +207,7 @@ export const OptimisticUpdates = () => {
         return null;
       }
 
-      return children;
+      return <>{children}</>;
     };
 
     describe('delete message', () => {
@@ -297,7 +338,7 @@ export const OptimisticUpdates = () => {
           localMessage: newMessage,
           message: newMessage,
           options: {},
-        });
+        } as unknown as Awaited<ReturnType<typeof channel.messageComposer.compose>>);
 
         render(
           <Chat client={chatClient} enableOfflineSupport>
@@ -340,7 +381,7 @@ export const OptimisticUpdates = () => {
               <CallbackEffectWithContext
                 callback={async ({ sendMessage }) => {
                   useMockedApis(chatClient, [sendMessageApi(newMessage)]);
-                  await sendMessage({ customMessageData: newMessage });
+                  await sendMessage();
                 }}
                 context={MessageInputContext}
               >
@@ -430,8 +471,8 @@ export const OptimisticUpdates = () => {
             <Channel
               channel={channel}
               doUpdateMessageRequest={
-                (async (_channelId, localMessage, options) => {
-                  await chatClient.offlineDb.addPendingTask({
+                (async (_channelId: string, localMessage: LocalMessage, options: unknown) => {
+                  await getOfflineDb(chatClient).addPendingTask({
                     channelId: channel.id,
                     channelType: channel.type,
                     messageId: message.id,
@@ -475,8 +516,8 @@ export const OptimisticUpdates = () => {
           const dbMessages = await BetterSqlite.selectFromTable('messages');
           const dbMessage = dbMessages.find((row) => row.id === message.id);
 
-          expect(updatedMessage.text).toBe(editedText);
-          expect(updatedMessage.message_text_updated_at).toBeTruthy();
+          expect(updatedMessage!.text).toBe(editedText);
+          expect(updatedMessage!.message_text_updated_at).toBeTruthy();
           expect(pendingTasksRows).toHaveLength(1);
           expect(pendingTasksRows[0].type).toBe('update-message');
           expect(dbMessage!.text).toBe(editedText);
@@ -527,7 +568,7 @@ export const OptimisticUpdates = () => {
           const dbMessages = await BetterSqlite.selectFromTable('messages');
           const dbMessage = dbMessages.find((row) => row.id === message.id);
 
-          expect(updatedMessage.text).toBe(editedText);
+          expect(updatedMessage!.text).toBe(editedText);
           expect(pendingTasksRows).toHaveLength(0);
           expect(dbMessage!.text).toBe(editedText);
         });
@@ -638,8 +679,8 @@ export const OptimisticUpdates = () => {
           const dbMessage = dbMessages.find((row) => row.id === message.id);
           const storedAttachments = JSON.parse(dbMessage!.attachments as string);
 
-          expect(updatedMessage.text).toBe(editedText);
-          expect(updatedMessage.attachments[0].asset_url).toBe(localUri);
+          expect(updatedMessage!.text).toBe(editedText);
+          expect(updatedMessage!.attachments![0].asset_url).toBe(localUri);
           expect(pendingTasksRows).toHaveLength(0);
           expect(dbMessage!.text).toBe(editedText);
           expect(storedAttachments[0].asset_url).toBe(localUri);
@@ -706,7 +747,7 @@ export const OptimisticUpdates = () => {
           localMessage: newMessage,
           message: newMessage,
           options: {},
-        });
+        } as unknown as Awaited<ReturnType<typeof channel.messageComposer.compose>>);
 
         // initialValue is needed as a prop to trick the message input ctx into thinking
         // we are sending a message.
@@ -760,11 +801,11 @@ export const OptimisticUpdates = () => {
           user_id: chatClient.userID,
         });
 
-        jest.spyOn(channel.messageComposer, 'compose').mockResolvedValue({
-          localMessage,
-          message: localMessage,
-          options: {},
-        });
+        jest
+          .spyOn(channel.messageComposer, 'compose')
+          .mockResolvedValue({ localMessage, message: localMessage } as unknown as Awaited<
+            ReturnType<typeof channel.messageComposer.compose>
+          >);
 
         render(
           <Chat client={chatClient} enableOfflineSupport>
@@ -783,23 +824,25 @@ export const OptimisticUpdates = () => {
         );
         await waitFor(() => expect(screen.getByTestId('children')).toBeTruthy());
 
-        let pendingTask;
+        let pendingTask: TestPendingTask | undefined;
         await waitFor(async () => {
-          const pendingTasks = await chatClient.offlineDb.getPendingTasks();
+          const pendingTasks = await getOfflineDb(chatClient).getPendingTasks();
           expect(pendingTasks).toHaveLength(1);
           pendingTask = pendingTasks[0];
         });
 
         expect(channel.state.messages.some((message) => message.id === localMessage.id)).toBe(true);
 
-        jest.spyOn(channel, 'watch').mockResolvedValue({});
+        jest
+          .spyOn(channel, 'watch')
+          .mockResolvedValue({} as Awaited<ReturnType<typeof channel.watch>>);
 
         channel.state.removeMessage(localMessage);
         channel.state.addMessageSorted(serverMessage, true);
-        await chatClient.offlineDb.deletePendingTask({ id: pendingTask.id });
+        await getOfflineDb(chatClient).deletePendingTask({ id: pendingTask!.id });
 
         await act(async () => {
-          await chatClient.offlineDb.syncManager.invokeSyncStatusListeners(true);
+          await getOfflineDb(chatClient).syncManager.invokeSyncStatusListeners(true);
         });
 
         await waitFor(() => {
@@ -821,11 +864,11 @@ export const OptimisticUpdates = () => {
           user_id: chatClient.userID,
         });
 
-        jest.spyOn(channel.messageComposer, 'compose').mockResolvedValue({
-          localMessage,
-          message: localMessage,
-          options: {},
-        });
+        jest
+          .spyOn(channel.messageComposer, 'compose')
+          .mockResolvedValue({ localMessage, message: localMessage } as unknown as Awaited<
+            ReturnType<typeof channel.messageComposer.compose>
+          >);
 
         render(
           <Chat client={chatClient} enableOfflineSupport>
@@ -844,20 +887,22 @@ export const OptimisticUpdates = () => {
         );
         await waitFor(() => expect(screen.getByTestId('children')).toBeTruthy());
 
-        let pendingTask;
+        let pendingTask: TestPendingTask | undefined;
         await waitFor(async () => {
-          const pendingTasks = await chatClient.offlineDb.getPendingTasks();
+          const pendingTasks = await getOfflineDb(chatClient).getPendingTasks();
           expect(pendingTasks).toHaveLength(1);
           pendingTask = pendingTasks[0];
         });
 
-        jest.spyOn(channel, 'watch').mockResolvedValue({});
+        jest
+          .spyOn(channel, 'watch')
+          .mockResolvedValue({} as Awaited<ReturnType<typeof channel.watch>>);
 
         channel.state.removeMessage(localMessage);
-        await chatClient.offlineDb.deletePendingTask({ id: pendingTask.id });
+        await getOfflineDb(chatClient).deletePendingTask({ id: pendingTask!.id });
 
         await act(async () => {
-          await chatClient.offlineDb.syncManager.invokeSyncStatusListeners(true);
+          await getOfflineDb(chatClient).syncManager.invokeSyncStatusListeners(true);
         });
 
         await waitFor(() => {

package/src/__tests__/offline-support/optimistic-update.tsx

@@ -195,14 +195,23 @@ describe('Giphy', () => {
     attachment.giphy = giphy;
     render(getAttachmentComponent({ attachment, giphyVersion: 'fixed_height' }));
     await waitFor(() => {
-      const checkImageProps = (imageProps, specificSizedGiphyData) => {
-        let imageStyle = imageProps.style;
+      const checkImageProps = (
+        imageProps: Record<string, unknown>,
+        specificSizedGiphyData: { height: string; url: string; width: string },
+      ) => {
+        let imageStyle = imageProps.style as
+          | Record<string, unknown>
+          | Array<Record<string, unknown>>;
         if (Array.isArray(imageStyle)) {
           imageStyle = Object.assign({}, ...imageStyle);
         }
-        expect(imageStyle.height).toBe(parseFloat(specificSizedGiphyData.height));
-        expect(imageStyle.width).toBe(parseFloat(specificSizedGiphyData.width));
-        expect(imageProps.source.uri).toBe(specificSizedGiphyData.url);
+        expect((imageStyle as Record<string, unknown>).height).toBe(
+          parseFloat(specificSizedGiphyData.height),
+        );
+        expect((imageStyle as Record<string, unknown>).width).toBe(
+          parseFloat(specificSizedGiphyData.width),
+        );
+        expect((imageProps.source as { uri: string }).uri).toBe(specificSizedGiphyData.url);
       };
       checkImageProps(
         screen.getByLabelText('Giphy Attachment Image').props,
@@ -211,14 +220,23 @@ describe('Giphy', () => {
     });
     render(getAttachmentComponent({ attachment, giphyVersion: 'original' }));
     await waitFor(() => {
-      const checkImageProps = (imageProps, specificSizedGiphyData) => {
-        let imageStyle = imageProps.style;
+      const checkImageProps = (
+        imageProps: Record<string, unknown>,
+        specificSizedGiphyData: { height: string; url: string; width: string },
+      ) => {
+        let imageStyle = imageProps.style as
+          | Record<string, unknown>
+          | Array<Record<string, unknown>>;
         if (Array.isArray(imageStyle)) {
           imageStyle = Object.assign({}, ...imageStyle);
         }
-        expect(imageStyle.height).toBe(parseFloat(specificSizedGiphyData.height));
-        expect(imageStyle.width).toBe(parseFloat(specificSizedGiphyData.width));
-        expect(imageProps.source.uri).toBe(specificSizedGiphyData.url);
+        expect((imageStyle as Record<string, unknown>).height).toBe(
+          parseFloat(specificSizedGiphyData.height),
+        );
+        expect((imageStyle as Record<string, unknown>).width).toBe(
+          parseFloat(specificSizedGiphyData.width),
+        );
+        expect((imageProps.source as { uri: string }).uri).toBe(specificSizedGiphyData.url);
       };
       checkImageProps(
         screen.getByLabelText('Giphy Attachment Image').props,

package/src/components/Attachment/__tests__/Giphy.test.tsx

@@ -1,18 +1,28 @@
 import React from 'react';
 
 import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react-native';
+import type { Channel as ChannelType, StreamChat } from 'stream-chat';
 
 import { OverlayProvider } from '../../../contexts';
 import { initiateClientWithChannels } from '../../../mock-builders/api/initiateClientWithChannels';
+import type { ChannelProps } from '../../Channel/Channel';
 import { Channel } from '../../Channel/Channel';
 import { Chat } from '../../Chat/Chat';
 import { AutoCompleteInput } from '../AutoCompleteInput';
 
-const renderComponent = ({ channelProps, client, props }) => {
+const renderComponent = ({
+  channelProps,
+  client,
+  props,
+}: {
+  channelProps: Partial<ChannelProps>;
+  client: StreamChat;
+  props: React.ComponentProps<typeof AutoCompleteInput>;
+}) => {
   return render(
     <OverlayProvider>
       <Chat client={client}>
-        <Channel {...channelProps}>
+        <Channel {...(channelProps as ChannelProps)}>
           <AutoCompleteInput {...props} />
         </Channel>
       </Chat>
@@ -21,8 +31,8 @@ const renderComponent = ({ channelProps, client, props }) => {
 };
 
 describe('AutoCompleteInput', () => {
-  let client;
-  let channel;
+  let client: StreamChat;
+  let channel: ChannelType;
 
   beforeEach(async () => {
     const { client: chatClient, channels } = await initiateClientWithChannels();
@@ -70,7 +80,7 @@ describe('AutoCompleteInput', () => {
   it('should have the maxLength same as the one on the config of channel', async () => {
     jest.spyOn(channel, 'getConfig').mockReturnValue({
       max_message_length: 10,
-    });
+    } as unknown as ReturnType<typeof channel.getConfig>);
     const channelProps = { channel };
     const props = {};