diff --git a/packages/core/types/src/dal/index.ts b/packages/core/types/src/dal/index.ts
index 7e3a858553359..ab99c2b13034b 100644
--- a/packages/core/types/src/dal/index.ts
+++ b/packages/core/types/src/dal/index.ts
@@ -23,7 +23,7 @@ export interface BaseFilterable<T> {
 /**
  * The options to apply when retrieving an item.
  */
-export interface OptionsQuery<T, P extends string = never> {
+export interface OptionsQuery<T> {
   /**
    * Relations to populate in the retrieved items.
    */
@@ -73,7 +73,7 @@ export type FindOptions<T = any> = {
   /**
    * The options to apply when retrieving the items.
    */
-  options?: OptionsQuery<InferEntityType<T>, any>
+  options?: OptionsQuery<InferEntityType<T>>
 }
 
 /**
diff --git a/packages/core/types/src/dal/repository-service.ts b/packages/core/types/src/dal/repository-service.ts
index 598c919d4f694..6aae45c990a4e 100644
--- a/packages/core/types/src/dal/repository-service.ts
+++ b/packages/core/types/src/dal/repository-service.ts
@@ -1,16 +1,23 @@
 import { RepositoryTransformOptions } from "../common"
 import { Context } from "../shared-context"
 import {
-  BaseFilterable,
-  FilterQuery,
   FilterQuery as InternalFilterQuery,
   FindOptions,
   UpsertWithReplaceConfig,
 } from "./index"
+import { EntityClass } from "@mikro-orm/core"
+import { IDmlEntity, InferTypeOf } from "../dml"
 
 type EntityClassName = string
 type EntityValues = { id: string }[]
 
+/**
+ * Either infer the properties from a DML object or from a Mikro orm class prototype.
+ */
+export type InferRepositoryReturnType<T> = T extends IDmlEntity<any, any>
+  ? InferTypeOf<T>
+  : EntityClass<T>["prototype"]
+
 export type PerformedActions = {
   created: Record<EntityClassName, EntityValues>
   updated: Record<EntityClassName, EntityValues>
@@ -22,7 +29,7 @@ export type PerformedActions = {
  * This layer helps to separate the business logic (service layer) from accessing the
  * ORM directly and allows to switch to another ORM without changing the business logic.
  */
-interface BaseRepositoryService<T = any> {
+interface BaseRepositoryService {
   transaction<TManager = unknown>(
     task: (transactionManager: TManager) => Promise<any>,
     context?: {
@@ -42,22 +49,28 @@ interface BaseRepositoryService<T = any> {
   ): Promise<TOutput>
 }
 
-export interface RepositoryService<T = any> extends BaseRepositoryService<T> {
-  find(options?: FindOptions<T>, context?: Context): Promise<T[]>
+export interface RepositoryService<T = any> extends BaseRepositoryService {
+  find(
+    options?: FindOptions<T>,
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]>
 
   findAndCount(
     options?: FindOptions<T>,
     context?: Context
-  ): Promise<[T[], number]>
-
-  create(data: any[], context?: Context): Promise<T[]>
+  ): Promise<[InferRepositoryReturnType<T>[], number]>
 
-  update(data: { entity; update }[], context?: Context): Promise<T[]>
+  create(
+    data: any[],
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]>
 
-  delete(
-    idsOrPKs: FilterQuery<T> & BaseFilterable<FilterQuery<T>>,
+  update(
+    data: { entity; update }[],
     context?: Context
-  ): Promise<void>
+  ): Promise<InferRepositoryReturnType<T>[]>
+
+  delete(idsOrPKs: FindOptions<T>["where"], context?: Context): Promise<void>
 
   /**
    * Soft delete entities and cascade to related entities if configured.
@@ -74,37 +87,45 @@ export interface RepositoryService<T = any> extends BaseRepositoryService<T> {
       | InternalFilterQuery
       | InternalFilterQuery[],
     context?: Context
-  ): Promise<[T[], Record<string, unknown[]>]>
+  ): Promise<[InferRepositoryReturnType<T>[], Record<string, unknown[]>]>
 
   restore(
     idsOrFilter: string[] | InternalFilterQuery,
     context?: Context
-  ): Promise<[T[], Record<string, unknown[]>]>
+  ): Promise<[InferRepositoryReturnType<T>[], Record<string, unknown[]>]>
 
-  upsert(data: any[], context?: Context): Promise<T[]>
+  upsert(
+    data: any[],
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]>
 
   upsertWithReplace(
     data: any[],
-    config?: UpsertWithReplaceConfig<T>,
+    config?: UpsertWithReplaceConfig<InferRepositoryReturnType<T>>,
     context?: Context
-  ): Promise<{ entities: T[]; performedActions: PerformedActions }>
+  ): Promise<{
+    entities: InferRepositoryReturnType<T>[]
+    performedActions: PerformedActions
+  }>
 }
 
-export interface TreeRepositoryService<T = any>
-  extends BaseRepositoryService<T> {
+export interface TreeRepositoryService<T = any> extends BaseRepositoryService {
   find(
     options?: FindOptions<T>,
     transformOptions?: RepositoryTransformOptions,
     context?: Context
-  ): Promise<T[]>
+  ): Promise<InferRepositoryReturnType<T>[]>
 
   findAndCount(
     options?: FindOptions<T>,
     transformOptions?: RepositoryTransformOptions,
     context?: Context
-  ): Promise<[T[], number]>
+  ): Promise<[InferRepositoryReturnType<T>[], number]>
 
-  create(data: unknown[], context?: Context): Promise<T[]>
+  create(
+    data: unknown[],
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]>
 
   delete(ids: string[], context?: Context): Promise<void>
 }
diff --git a/packages/core/types/src/dal/utils.ts b/packages/core/types/src/dal/utils.ts
index f99a7e49f4750..90151ec62b99d 100644
--- a/packages/core/types/src/dal/utils.ts
+++ b/packages/core/types/src/dal/utils.ts
@@ -1,3 +1,5 @@
+import { Constructor } from "../modules-sdk"
+
 type ExpandProperty<T> = T extends (infer U)[] ? NonNullable<U> : NonNullable<T>
 
 export type Dictionary<T = any> = {
@@ -84,25 +86,29 @@ type FilterValue<T> =
 
 type PrevLimit = [never, 0, 1, 2]
 
+export type FilterQueryProperties<T, Prev extends number = 3> = {
+  [Key in keyof T]?: T[Key] extends
+    | boolean
+    | number
+    | string
+    | bigint
+    | symbol
+    | Date
+    ? T[Key] | OperatorMap<T[Key]>
+    : T[Key] extends infer U
+    ? U extends { [x: number]: infer V }
+      ? V extends object
+        ? FilterQuery<Partial<V>, PrevLimit[Prev]>
+        : never
+      : never
+    : never
+}
+
 export type FilterQuery<T = any, Prev extends number = 3> = Prev extends never
   ? never
-  : {
-      [Key in keyof T]?: T[Key] extends
-        | boolean
-        | number
-        | string
-        | bigint
-        | symbol
-        | Date
-        ? T[Key] | OperatorMap<T[Key]>
-        : T[Key] extends infer U
-        ? U extends { [x: number]: infer V }
-          ? V extends object
-            ? FilterQuery<Partial<V>, PrevLimit[Prev]>
-            : never
-          : never
-        : never
-    }
+  : T extends Constructor<infer Prototype>
+  ? FilterQueryProperties<Prototype, Prev>
+  : FilterQueryProperties<T, Prev>
 
 declare type QueryOrder = "ASC" | "DESC" | "asc" | "desc"
 
diff --git a/packages/core/utils/src/dal/mikro-orm/integration-tests/__tests__/mikro-orm-repository.spec.ts b/packages/core/utils/src/dal/mikro-orm/integration-tests/__tests__/mikro-orm-repository.spec.ts
index 8ffef62387006..2c5f51541f739 100644
--- a/packages/core/utils/src/dal/mikro-orm/integration-tests/__tests__/mikro-orm-repository.spec.ts
+++ b/packages/core/utils/src/dal/mikro-orm/integration-tests/__tests__/mikro-orm-repository.spec.ts
@@ -120,9 +120,9 @@ class Entity3 {
   }
 }
 
-const Entity1Repository = mikroOrmBaseRepositoryFactory<Entity1>(Entity1)
-const Entity2Repository = mikroOrmBaseRepositoryFactory<Entity2>(Entity2)
-const Entity3Repository = mikroOrmBaseRepositoryFactory<Entity3>(Entity3)
+const Entity1Repository = mikroOrmBaseRepositoryFactory(Entity1)
+const Entity2Repository = mikroOrmBaseRepositoryFactory(Entity2)
+const Entity3Repository = mikroOrmBaseRepositoryFactory(Entity3)
 
 describe("mikroOrmRepository", () => {
   let orm!: MikroORM
diff --git a/packages/core/utils/src/dal/mikro-orm/mikro-orm-repository.ts b/packages/core/utils/src/dal/mikro-orm/mikro-orm-repository.ts
index 902f16fa37ad5..822c181f9cf9d 100644
--- a/packages/core/utils/src/dal/mikro-orm/mikro-orm-repository.ts
+++ b/packages/core/utils/src/dal/mikro-orm/mikro-orm-repository.ts
@@ -3,8 +3,9 @@ import {
   Context,
   DAL,
   FilterQuery,
-  InferEntityType,
   FilterQuery as InternalFilterQuery,
+  InferEntityType,
+  InferRepositoryReturnType,
   PerformedActions,
   RepositoryService,
   RepositoryTransformOptions,
@@ -92,7 +93,7 @@ export class MikroOrmBase {
  * related ones.
  */
 
-export class MikroOrmBaseRepository<T extends object = object>
+export class MikroOrmBaseRepository<const T extends object>
   extends MikroOrmBase
   implements RepositoryService<T>
 {
@@ -148,11 +149,17 @@ export class MikroOrmBaseRepository<T extends object = object>
     })
   }
 
-  create(data: unknown[], context?: Context): Promise<T[]> {
+  create(
+    data: unknown[],
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]> {
     throw new Error("Method not implemented.")
   }
 
-  update(data: { entity; update }[], context?: Context): Promise<T[]> {
+  update(
+    data: { entity; update }[],
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]> {
     throw new Error("Method not implemented.")
   }
 
@@ -163,28 +170,37 @@ export class MikroOrmBaseRepository<T extends object = object>
     throw new Error("Method not implemented.")
   }
 
-  find(options?: DAL.FindOptions<T>, context?: Context): Promise<T[]> {
+  find(
+    options?: DAL.FindOptions<T>,
+    context?: Context
+  ): Promise<InferRepositoryReturnType<T>[]> {
     throw new Error("Method not implemented.")
   }
 
   findAndCount(
     options?: DAL.FindOptions<T>,
     context?: Context
-  ): Promise<[T[], number]> {
+  ): Promise<[InferRepositoryReturnType<T>[], number]> {
     throw new Error("Method not implemented.")
   }
 
-  upsert(data: unknown[], context: Context = {}): Promise<T[]> {
+  upsert(
+    data: unknown[],
+    context: Context = {}
+  ): Promise<InferRepositoryReturnType<T>[]> {
     throw new Error("Method not implemented.")
   }
 
   upsertWithReplace(
     data: unknown[],
-    config: UpsertWithReplaceConfig<T> = {
+    config: UpsertWithReplaceConfig<InferRepositoryReturnType<T>> = {
       relations: [],
     },
     context: Context = {}
-  ): Promise<{ entities: T[]; performedActions: PerformedActions }> {
+  ): Promise<{
+    entities: InferRepositoryReturnType<T>[]
+    performedActions: PerformedActions
+  }> {
     throw new Error("Method not implemented.")
   }
 
@@ -192,10 +208,10 @@ export class MikroOrmBaseRepository<T extends object = object>
     filters:
       | string
       | string[]
-      | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)
-      | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)[],
+      | DAL.FindOptions<T>["where"]
+      | DAL.FindOptions<T>["where"][],
     sharedContext: Context = {}
-  ): Promise<[T[], Record<string, unknown[]>]> {
+  ): Promise<[InferRepositoryReturnType<T>[], Record<string, unknown[]>]> {
     const entities = await this.find({ where: filters as any }, sharedContext)
     const date = new Date()
 
@@ -216,8 +232,8 @@ export class MikroOrmBaseRepository<T extends object = object>
   async restore(
     idsOrFilter: string[] | InternalFilterQuery,
     sharedContext: Context = {}
-  ): Promise<[T[], Record<string, unknown[]>]> {
-    const query = buildQuery(idsOrFilter, {
+  ): Promise<[InferRepositoryReturnType<T>[], Record<string, unknown[]>]> {
+    const query = buildQuery<T>(idsOrFilter, {
       withDeleted: true,
     })
 
@@ -290,7 +306,7 @@ export class MikroOrmBaseTreeRepository<
   }
 }
 
-export function mikroOrmBaseRepositoryFactory<T extends object>(
+export function mikroOrmBaseRepositoryFactory<const T extends object>(
   entity: T
 ): {
   new ({ manager }: { manager: any }): MikroOrmBaseRepository<T>
@@ -328,7 +344,7 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
     async create(
       data: any[],
       context?: Context
-    ): Promise<InferEntityType<T>[]> {
+    ): Promise<InferRepositoryReturnType<T>[]> {
       const manager = this.getActiveManager<EntityManager>(context)
 
       const entities = data.map((data_) => {
@@ -340,7 +356,7 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
 
       manager.persist(entities)
 
-      return entities as InferEntityType<T>[]
+      return entities as InferRepositoryReturnType<T>[]
     }
 
     /**
@@ -410,7 +426,10 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
       }
     }
 
-    async update(data: { entity; update }[], context?: Context): Promise<T[]> {
+    async update(
+      data: { entity; update }[],
+      context?: Context
+    ): Promise<InferRepositoryReturnType<T>[]> {
       const manager = this.getActiveManager<EntityManager>(context)
 
       await this.initManyToManyToDetachAllItemsIfNeeded(data, context)
@@ -432,9 +451,9 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
     }
 
     async find(
-      options: DAL.FindOptions<T> = { where: {} },
+      options: DAL.FindOptions<T> = { where: {} } as DAL.FindOptions<T>,
       context?: Context
-    ): Promise<T[]> {
+    ): Promise<InferRepositoryReturnType<T>[]> {
       const manager = this.getActiveManager<EntityManager>(context)
 
       const findOptions_ = { ...options }
@@ -456,17 +475,17 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
         findOptions: findOptions_,
       })
 
-      return await manager.find(
+      return (await manager.find(
         entity as EntityName<T>,
         findOptions_.where as MikroFilterQuery<T>,
         findOptions_.options as MikroOptions<T>
-      )
+      )) as InferRepositoryReturnType<T>[]
     }
 
     async findAndCount(
-      findOptions: DAL.FindOptions<T> = { where: {} },
+      findOptions: DAL.FindOptions<T> = { where: {} } as DAL.FindOptions<T>,
       context: Context = {}
-    ): Promise<[T[], number]> {
+    ): Promise<[InferRepositoryReturnType<T>[], number]> {
       const manager = this.getActiveManager<EntityManager>(context)
 
       const findOptions_ = { ...findOptions }
@@ -480,14 +499,17 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
         findOptions: findOptions_,
       })
 
-      return await manager.findAndCount(
+      return (await manager.findAndCount(
         entity as EntityName<T>,
         findOptions_.where as MikroFilterQuery<T>,
         findOptions_.options as MikroOptions<T>
-      )
+      )) as [InferRepositoryReturnType<T>[], number]
     }
 
-    async upsert(data: any[], context: Context = {}): Promise<T[]> {
+    async upsert(
+      data: any[],
+      context: Context = {}
+    ): Promise<InferRepositoryReturnType<T>[]> {
       const manager = this.getActiveManager<EntityManager>(context)
 
       const primaryKeys = MikroOrmAbstractBaseRepository_.retrievePrimaryKeys(
@@ -511,7 +533,7 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
         }))
       }
 
-      let allEntities: T[][] = []
+      let allEntities: InferRepositoryReturnType<T>[][] = []
 
       if (primaryKeysCriteria.length) {
         allEntities = await Promise.all(
@@ -527,7 +549,10 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
 
       const existingEntities = allEntities.flat()
 
-      const existingEntitiesMap = new Map<string, T>()
+      const existingEntitiesMap = new Map<
+        string,
+        InferRepositoryReturnType<T>
+      >()
       existingEntities.forEach((entity) => {
         if (entity) {
           const key =
@@ -539,9 +564,9 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
         }
       })
 
-      const upsertedEntities: T[] = []
-      const createdEntities: T[] = []
-      const updatedEntities: T[] = []
+      const upsertedEntities: InferRepositoryReturnType<T>[] = []
+      const createdEntities: InferRepositoryReturnType<T>[] = []
+      const updatedEntities: InferRepositoryReturnType<T>[] = []
 
       data.forEach((data_) => {
         // In case the data provided are just strings, then we build an object with the primary key as the key and the data as the valuecd -
@@ -556,8 +581,8 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
           const updatedType = manager.assign(existingEntity, data_)
           updatedEntities.push(updatedType)
         } else {
-          const newEntity = manager.create<T>(this.entity, data_)
-          createdEntities.push(newEntity)
+          const newEntity = manager.create(this.entity, data_)
+          createdEntities.push(newEntity as InferRepositoryReturnType<T>)
         }
       })
 
@@ -572,7 +597,7 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
       }
 
       // TODO return the all, created, updated entities
-      return upsertedEntities
+      return upsertedEntities as InferRepositoryReturnType<T>[]
     }
 
     // UpsertWithReplace does several things to simplify module implementation.
@@ -584,11 +609,14 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
     // We only support 1-level depth of upserts. We don't support custom fields on the many-to-many pivot tables for now
     async upsertWithReplace(
       data: any[],
-      config: UpsertWithReplaceConfig<T> = {
+      config: UpsertWithReplaceConfig<InferRepositoryReturnType<T>> = {
         relations: [],
       },
       context: Context = {}
-    ): Promise<{ entities: T[]; performedActions: PerformedActions }> {
+    ): Promise<{
+      entities: InferRepositoryReturnType<T>[]
+      performedActions: PerformedActions
+    }> {
       const performedActions: PerformedActions = {
         created: {},
         updated: {},
@@ -972,10 +1000,10 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
       filters:
         | string
         | string[]
-        | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)
-        | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)[],
+        | DAL.FindOptions<T>["where"]
+        | DAL.FindOptions<T>["where"][],
       sharedContext: Context = {}
-    ): Promise<[T[], Record<string, unknown[]>]> {
+    ): Promise<[InferRepositoryReturnType<T>[], Record<string, unknown[]>]> {
       if (Array.isArray(filters) && !filters.filter(Boolean).length) {
         return [[], {}]
       }
@@ -993,10 +1021,10 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
       filters:
         | string
         | string[]
-        | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)
-        | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)[],
+        | DAL.FindOptions<T>["where"]
+        | DAL.FindOptions<T>["where"][],
       sharedContext: Context = {}
-    ): Promise<[T[], Record<string, unknown[]>]> {
+    ): Promise<[InferRepositoryReturnType<T>[], Record<string, unknown[]>]> {
       if (Array.isArray(filters) && !filters.filter(Boolean).length) {
         return [[], {}]
       }
@@ -1014,9 +1042,9 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
       filters:
         | string
         | string[]
-        | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)
-        | (FilterQuery<T> & BaseFilterable<FilterQuery<T>>)[]
-    ) {
+        | DAL.FindOptions<T>["where"]
+        | DAL.FindOptions<T>["where"][]
+    ): DAL.FindOptions<T>["where"] {
       const primaryKeys = MikroOrmAbstractBaseRepository_.retrievePrimaryKeys(
         this.entity
       )
@@ -1033,7 +1061,7 @@ export function mikroOrmBaseRepositoryFactory<T extends object>(
         }),
       }
 
-      return normalizedFilters
+      return normalizedFilters as DAL.FindOptions<T>["where"]
     }
   }
 
diff --git a/packages/core/utils/src/modules-sdk/build-query.ts b/packages/core/utils/src/modules-sdk/build-query.ts
index 63da37fa6ebac..3dbbd22924b6e 100644
--- a/packages/core/utils/src/modules-sdk/build-query.ts
+++ b/packages/core/utils/src/modules-sdk/build-query.ts
@@ -1,4 +1,4 @@
-import { DAL, FindConfig } from "@medusajs/types"
+import { DAL, FindConfig, InferRepositoryReturnType } from "@medusajs/types"
 import { deduplicate, isObject } from "../common"
 
 import { SoftDeletableFilterKey } from "../dal/mikro-orm/mikro-orm-soft-deletable-filter"
@@ -10,17 +10,19 @@ type FilterFlags = {
   withDeleted?: boolean
 }
 
-export function buildQuery<T = any, TDto = any>(
+export function buildQuery<const T = any>(
   filters: Record<string, any> = {},
-  config: FindConfig<TDto> & { primaryKeyFields?: string | string[] } = {}
+  config: FindConfig<InferRepositoryReturnType<T>> & {
+    primaryKeyFields?: string | string[]
+  } = {}
 ): Required<DAL.FindOptions<T>> {
-  const where: DAL.FilterQuery<T> = {}
+  const where = {} as DAL.FilterQuery<T>
   const filterFlags: FilterFlags = {}
   buildWhere(filters, where, filterFlags)
 
   delete config.primaryKeyFields
 
-  const findOptions: DAL.OptionsQuery<T, any> = {
+  const findOptions: DAL.FindOptions<T>["options"] = {
     populate: deduplicate(config.relations ?? []),
     fields: config.select as string[],
     limit: (Number.isSafeInteger(config.take) && config.take) || undefined,
@@ -28,7 +30,9 @@ export function buildQuery<T = any, TDto = any>(
   }
 
   if (config.order) {
-    findOptions.orderBy = config.order as DAL.OptionsQuery<T>["orderBy"]
+    findOptions.orderBy = config.order as Required<
+      DAL.FindOptions<T>
+    >["options"]["orderBy"]
   }
 
   if (config.withDeleted || filterFlags.withDeleted) {
@@ -50,7 +54,7 @@ export function buildQuery<T = any, TDto = any>(
     Object.assign(findOptions, config.options)
   }
 
-  return { where, options: findOptions }
+  return { where, options: findOptions } as Required<DAL.FindOptions<T>>
 }
 
 function buildWhere(
diff --git a/packages/core/utils/src/modules-sdk/medusa-internal-service.ts b/packages/core/utils/src/modules-sdk/medusa-internal-service.ts
index cdd358c38e28e..3689869adbe48 100644
--- a/packages/core/utils/src/modules-sdk/medusa-internal-service.ts
+++ b/packages/core/utils/src/modules-sdk/medusa-internal-service.ts
@@ -2,9 +2,9 @@ import {
   BaseFilterable,
   Context,
   FilterQuery,
+  FilterQuery as InternalFilterQuery,
   FindConfig,
   InferEntityType,
-  FilterQuery as InternalFilterQuery,
   ModulesSdkTypes,
   PerformedActions,
   UpsertWithReplaceConfig,
@@ -62,7 +62,7 @@ export function MedusaInternalService<
     }
 
     static applyFreeTextSearchFilter(
-      filters: FilterQuery,
+      filters: FilterQuery & { q?: string },
       config: FindConfig<any>
     ): void {
       if (isDefined(filters?.q)) {