не получается воспользоваться query в trpc

всем привет! пытаюсь сделать бэк для некста с trpc. пост запросы проходят, но геты с квери совсем не получается. выяснил что нужно из клиента их кидать. решил сделать тестовые запросы при загрузке главной. не находит .query у методов

page.tsx
'use client'
import dynamic from 'next/dynamic'
import { ClientLayout } from '@/layout/clientLayout'
import Provider from './api/trpc/[trpc]/_trpc/Provider'
import { useEffect } from 'react'
import { getChannels, getMyChannels, getMyOrders } from './server/utils/api'

const MainScreen = dynamic(() => import('@/components/mainSceen'), {
    ssr: false,
})

function Home() {
    useEffect(() => {
        const fetchData = async () => {
            await getChannels({
                //что-то будет
            })
            await getMyChannels('my-user-id-here')
            await getMyOrders('my-user-id-here')
        }

        fetchData()
    }, [])
    return (
        <Provider>
            <ClientLayout>
                <main>
                    <MainScreen />
                </main>
            </ClientLayout>
        </Provider>
    )
}

export default Home

Provider.tsx
'use client'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { httpBatchLink } from '@trpc/client'
import React, { useState } from 'react'
import { trpc } from './client'
import type { AppRouter } from '../../../../server'

export default function Provider({ children }: { children: React.ReactNode }) {
    const [queryClient] = useState(() => new QueryClient({}))
    const [trpcClient] = useState(() =>
        trpc.createClient({
            links: [
                httpBatchLink({
                    url: 'http://localhost:3000/api/trpc',
                }),
            ],
        })
    )
    return (
        <trpc.Provider client={trpcClient} queryClient={queryClient}>
            <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
        </trpc.Provider>
    )
}

client.ts
import { createTRPCReact } from '@trpc/react-query'
import type { AppRouter } from '../../../../server'

export const trpc = createTRPCReact<AppRouter>()```

методы
```getChannels: publicProcedure
        .input(
            z.union([
                z.object({
                    nameChanel: z.string().optional(),
                    category: z.string().optional(),
                    minPrice: z
                        .string()
                        .regex(/^\d+$/, 'Цена должна содержать только цифры')
                        .optional(),
                    maxPrice: z
                        .string()
                        .regex(/^\d+$/, 'Цена должна содержать только цифры')
                        .optional(),
                }),
                z.undefined(),
            ])
        )
        .query(async ({ input }) => {
            try {
                const filters: any = {}

                if (input) {
                    if (input.nameChanel) {
                        filters['nameChanel'] = {
                            $regex: new RegExp(input.nameChanel, 'i'),
                        }
                    }

                    if (input.category) {
                        filters['category'] = input.category
                    }

                    if (input.minPrice || input.maxPrice) {
                        filters['price'] = {}

                        if (input.minPrice) {
                            filters['price']['$gte'] = parseInt(input.minPrice, 10)
                        }

                        if (input.maxPrice) {
                            filters['price']['$lte'] = parseInt(input.maxPrice, 10)
                        }
                    }
                }

                const channels = await Channel.find(filters)

                return {
                    success: true,
                    message: 'Channels retrieved successfully',
                    data: channels,
                }
            } catch (error) {
                const err = error as Error
                return {
                    success: false,
                    message: 'Failed to retrieve channels',
                    error: err.message,
                }
            }
        }),

myChannels: publicProcedure
        .input(
            z.object({
                userId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Invalid user ID'),
            })
        )
        .query(async ({ input }) => {
            try {
                const orders = await Order.find({ userId: input.userId })
                const channelIds = orders.map(order => order.channelId)
                const channels = await Channel.find({ _id: { $in: channelIds } })

                return {
                    success: true,
                    message: 'Channels retrieved successfully',
                    data: channels,
                }
            } catch (error) {
                const err = error as Error
                return {
                    success: false,
                    message: 'Failed to retrieve channels',
                    error: err.message,
                }
            }
        }),
    myOrders: publicProcedure
        .input(
            z.object({
                userId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Invalid user ID'),
            })
        )
        .query(async ({ input }) => {
            try {
                const orders = await Order.find({ userId: input.userId }).populate(
                    'channelId'
                )

                return {
                    success: true,
                    message: 'Orders retrieved successfully',
                    data: orders,
                }
            } catch (error) {
                const err = error as Error
                return {
                    success: false,
                    message: 'Failed to retrieve orders',
                    error: err.message,
                }
            }
        }),

api.ts
import { trpc } from '../../api/trpc/[trpc]/_trpc/client'

export const getChannels = async (filters?: {
    nameChanel?: string
    category?: string
    minPrice?: string
    maxPrice?: string
}) => {
    try {
        const response = await trpc.getChannels.query(filters)
        console.log('Channels:', response)
        return response
    } catch (error) {
        console.error('Error fetching channels:', error)
        throw error
    }
}

export const getMyChannels = async (userId: string) => {
    try {
        const response = await trpc.myChannels.query({ userId })
        console.log('My Channels:', response)
        return response
    } catch (error) {
        console.error('Error fetching my channels:', error)
        throw error
    }
}

export const getMyOrders = async (userId: string) => {
    try {
        const response = await trpc.myOrders.query({ userId })
        console.log('My Orders:', response)
        return response
    } catch (error) {
        console.error('Error fetching my orders:', error)
        throw error
    }
}