docs: replace ModuleRegistrationName with Modules (#9142)

www/apps/book/app/advanced-development/api-routes/protected-routes/page.mdx

@@ -119,7 +119,7 @@ import type {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "@medusajs/medusa"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 import { ICustomerModuleService } from "@medusajs/types"
 
 export const GET = async (
@@ -129,7 +129,7 @@ export const GET = async (
   if (req.auth_context?.actor_id) {
     // retrieve customer
     const customerModuleService: ICustomerModuleService = req.scope.resolve(
-      ModuleRegistrationName.CUSTOMER
+      Modules.CUSTOMER
     )
 
     const customer = await customerModuleService.retrieveCustomer(
@@ -154,7 +154,7 @@ import type {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "@medusajs/medusa"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 import { IUserModuleService } from "@medusajs/types"
 
 export const GET = async (
@@ -162,7 +162,7 @@ export const GET = async (
   res: MedusaResponse
 ) => {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const user = await userModuleService.retrieveUser(

www/apps/book/app/advanced-development/custom-cli-scripts/page.mdx

@@ -23,11 +23,11 @@ import {
   ExecArgs,
   IProductModuleService,
 } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export default async function myScript({ container }: ExecArgs) {
   const productModuleService: IProductModuleService = container.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const [, count] = await productModuleService

www/apps/book/app/advanced-development/workflows/advanced-example/page.mdx

@@ -49,14 +49,14 @@ export const updateProductHighlights = [
 ```ts title="src/workflows/update-product-erp/steps/update-product.ts" highlights={updateProductHighlights} collapsibleLines="1-9" expandButtonLabel="Show Imports"
 import { createStep, StepResponse } from "@medusajs/workflows-sdk"
 import { IProductModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 import { UpdateProductAndErpWorkflowInput } from ".."
 
 const updateProduct = createStep(
   "update-product",
   async (input: UpdateProductAndErpWorkflowInput, context) => {
     const productModuleService: IProductModuleService =
-      context.container.resolve(ModuleRegistrationName.PRODUCT)
+      context.container.resolve(Modules.PRODUCT)
 
     const { id } = input
     const previousProductData =
@@ -72,7 +72,7 @@ const updateProduct = createStep(
   // compensation function
   async ({ previousProductData }, context) => {
     const productModuleService: IProductModuleService =
-      context.container.resolve(ModuleRegistrationName.PRODUCT)
+      context.container.resolve(Modules.PRODUCT)
 
     const { id, type, options, variants, ...previousData } = previousProductData
 

www/apps/book/app/advanced-development/workflows/long-running-workflow/page.mdx

@@ -73,7 +73,7 @@ So, when you execute the `hello-world` workflow, it continues its execution in t
 
 Once the workflow's execution reaches an async step, it'll wait in the background for the step to succeed or fail before it moves to the rest of the steps.
 
-To change fail or succeed a step, use the workflow engine's main service that is registered in the Medusa Container under the `ModuleRegistrationName.WORKFLOW_ENGINE` (or `workflowsModuleService`) key.
+To change fail or succeed a step, use the workflow engine's main service that is registered in the Medusa Container under the `Modules.WORKFLOW_ENGINE` (or `workflowsModuleService`) key.
 
 ### Retrieve Transaction ID
 
@@ -103,7 +103,7 @@ export const successStatusHighlights = [
 
 ```ts highlights={successStatusHighlights} collapsibleLines="1-9" expandButtonLabel="Show Imports"
 import {
-  ModuleRegistrationName,
+  Modules,
   TransactionHandlerType,
 } from "@medusajs/utils";
 import { 
@@ -122,7 +122,7 @@ export const setStepSuccessStep = createStep(
     { container }
   ) {
     const workflowEngineService = container.resolve(
-      ModuleRegistrationName.WORKFLOW_ENGINE
+      Modules.WORKFLOW_ENGINE
     );
 
     await workflowEngineService.setStepSuccess({
@@ -221,7 +221,7 @@ export const failureStatusHighlights = [
 
 ```ts highlights={failureStatusHighlights} collapsibleLines="1-9" expandButtonLabel="Show Imports"
 import {
-  ModuleRegistrationName,
+  Modules,
   TransactionHandlerType,
 } from "@medusajs/utils";
 import { 
@@ -240,7 +240,7 @@ export const setStepFailureStep = createStep(
     { container }
   ) {
     const workflowEngineService = container.resolve(
-      ModuleRegistrationName.WORKFLOW_ENGINE
+      Modules.WORKFLOW_ENGINE
     );
 
     await workflowEngineService.setStepFailure({
@@ -282,7 +282,7 @@ import myWorkflow from "../../../workflows/hello-world"
 import { 
   IWorkflowEngineService,
 } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export async function GET(req: MedusaRequest, res: MedusaResponse) {
   const { transaction, result } = await myWorkflow(req.scope).run()
@@ -290,7 +290,7 @@ export async function GET(req: MedusaRequest, res: MedusaResponse) {
   const workflowEngineService = req.scope.resolve<
     IWorkflowEngineService
   >(
-    ModuleRegistrationName.WORKFLOW_ENGINE
+    Modules.WORKFLOW_ENGINE
   )
 
   const subscriptionOptions = {

www/apps/book/app/basics/commerce-modules/page.mdx

@@ -27,14 +27,14 @@ For example, you saw this code snippet in the [Medusa container chapter](../medu
 ```ts highlights={[["10"]]}
 import type { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
 import { IProductModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export const GET = async (
   req: MedusaRequest, 
   res: MedusaResponse
 ) => {
   const productModuleService: IProductModuleService = req.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const [, count] = await productModuleService
@@ -46,10 +46,10 @@ export const GET = async (
 }
 ```
 
-When you resolve the `ModuleRegistrationName.PRODUCT` (or `productModuleService`) registration name, you're actually resolving the main service of the Product Module.
+When you resolve the `Modules.PRODUCT` (or `productModuleService`) registration name, you're actually resolving the main service of the Product Module.
 
 <Note title="Tip">
 
-To resolve the main service of any commerce module, use the registration name defined in the `ModuleRegistrationName` enum imported from `@medusajs/utils`.
+To resolve the main service of any commerce module, use the registration name defined in the `Modules` enum imported from `@medusajs/utils`.
 
 </Note>

www/apps/book/app/basics/events-and-subscribers/page.mdx

@@ -85,20 +85,20 @@ For example:
 export const highlights = [
   ["7", "container", "Recieve the Medusa Container in the object parameter."],
   ["10", "resolve", "Resolve the Product Module's main service."],
-  ["10", "ModuleRegistrationName.PRODUCT", "The module's registration name imported from `@medusajs/utils`."]
+  ["10", "Modules.PRODUCT", "The module's registration name imported from `@medusajs/utils`."]
 ]
 
 ```ts title="src/subscribers/product-created.ts" highlights={highlights}
 import { SubscriberArgs, type SubscriberConfig } from "@medusajs/medusa"
 import { IProductModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export default async function productCreateHandler({
   event: { data },
   container,
 }: SubscriberArgs<{ id: string }>) {
   const productModuleService: IProductModuleService =
-    container.resolve(ModuleRegistrationName.PRODUCT)
+    container.resolve(Modules.PRODUCT)
 
   const productId = data.id
 

www/apps/book/app/basics/medusa-container/page.mdx

@@ -18,7 +18,7 @@ export const highlights = [
   ["9", "resolve", "Resolve the Product Module's main service."],
   [
     "10",
-    "ModuleRegistrationName.PRODUCT",
+    "Modules.PRODUCT",
     "The resource registration name imported from `@medusajs/utils`.",
   ],
 ]
@@ -26,14 +26,14 @@ export const highlights = [
 ```ts highlights={highlights}
 import type { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
 import { IProductModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export const GET = async (
   req: MedusaRequest, 
   res: MedusaResponse
 ) => {
   const productModuleService: IProductModuleService = req.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const [, count] = await productModuleService

www/apps/book/app/basics/scheduled-jobs/page.mdx

@@ -87,7 +87,7 @@ For example:
 
 export const highlights = [
   ["11", "resolve", "Resolve the Product Module's main service."],
-  ["11", "ModuleRegistrationName.PRODUCT", "The module's registration name imported from `@medusajs/utils`."]
+  ["11", "Modules.PRODUCT", "The module's registration name imported from `@medusajs/utils`."]
 ]
 
 ```ts title="src/jobs/hello-world.ts" highlights={highlights}
@@ -95,13 +95,13 @@ import {
   IProductModuleService,
   MedusaContainer,
 } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export default async function myCustomJob(
   container: MedusaContainer
 ) {
   const productModuleService: IProductModuleService = 
-    container.resolve(ModuleRegistrationName.PRODUCT)
+    container.resolve(Modules.PRODUCT)
 
   const [, count] = await productModuleService.listAndCountProducts()
 

www/apps/book/app/basics/workflows/page.mdx

@@ -127,7 +127,7 @@ To execute the workflow, invoke it passing the Medusa container as a parameter.
       type SubscriberArgs,
     } from "@medusajs/medusa"
     import myWorkflow from "../workflows/hello-world"
-    import { ModuleRegistrationName } from "@medusajs/utils"
+    import { Modules } from "@medusajs/utils"
     import { IUserModuleService } from "@medusajs/types"
 
     export default async function handleCustomerCreate({
@@ -136,7 +136,7 @@ To execute the workflow, invoke it passing the Medusa container as a parameter.
     }: SubscriberArgs<{ id: string }>) {
       const userId = data.id
       const userModuleService: IUserModuleService = container.resolve(
-        ModuleRegistrationName.USER
+        Modules.USER
       )
 
       const user = await userModuleService.retrieveUser(userId)
@@ -231,7 +231,7 @@ export const highlights = [
   ["12", "resolve", "Resolve the Product Module's main service."],
   [
     "12",
-    "ModuleRegistrationName.PRODUCT",
+    "Modules.PRODUCT",
     "The resource registration name imported from `@medusajs/utils`.",
   ],
 ]
@@ -244,11 +244,11 @@ import {
   WorkflowResponse,
 } from "@medusajs/workflows-sdk"
 import { IProductModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, context) => {
   const productModuleService: IProductModuleService =
-    context.container.resolve(ModuleRegistrationName.PRODUCT)
+    context.container.resolve(Modules.PRODUCT)
 
   const [, count] = await productModuleService.listAndCountProducts()
 

www/apps/resources/app/architectural-modules/notification/send-notification/page.mdx

@@ -37,7 +37,7 @@ import type {
   SubscriberArgs,
   SubscriberConfig,
 } from "@medusajs/medusa"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 import { INotificationModuleService } from "@medusajs/types"
 
 export default async function productCreateHandler({
@@ -45,7 +45,7 @@ export default async function productCreateHandler({
   container,
 }: SubscriberArgs<{ id: string }>) {
   const notificationModuleService: INotificationModuleService =
-    container.resolve(ModuleRegistrationName.NOTIFICATION)
+    container.resolve(Modules.NOTIFICATION)
 
   await notificationModuleService.createNotifications({
     to: "shahednasser@gmail.com",

www/apps/resources/app/architectural-modules/notification/sendgrid/page.mdx

@@ -144,7 +144,7 @@ import type {
   SubscriberArgs,
   SubscriberConfig,
 } from "@medusajs/medusa"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 import { INotificationModuleService } from "@medusajs/types"
 
 export default async function productCreateHandler({
@@ -152,7 +152,7 @@ export default async function productCreateHandler({
   container,
 }: SubscriberArgs<{ id: string }>) {
   const notificationModuleService: INotificationModuleService =
-    container.resolve(ModuleRegistrationName.NOTIFICATION)
+    container.resolve(Modules.NOTIFICATION)
 
   await notificationModuleService.createNotifications({
     to: "test@gmail.com",

www/apps/resources/app/commerce-modules/api-key/examples/page.mdx

@@ -16,11 +16,11 @@ In this guide, you’ll find common examples of how you can use the API Key Modu
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const apiKeyModuleService: IApiKeyModuleService = request.scope.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   const apiKey = await apiKeyModuleService.createApiKeys({
@@ -71,11 +71,11 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(request: MedusaRequest, res: MedusaResponse) {
   const apiKeyModuleService: IApiKeyModuleService = request.scope.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   res.json({
@@ -114,14 +114,14 @@ export async function GET(request: Request) {
 ```ts collapsibleLines="1-9" expandButtonLabel="Show Imports"
 import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/medusa"
 import { IApiKeyModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: AuthenticatedMedusaRequest,
   res: MedusaResponse
 ) {
   const apiKeyModuleService: IApiKeyModuleService = request.scope.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   const revokedKey = await apiKeyModuleService.revoke(request.params.id, {
@@ -175,11 +175,11 @@ export async function POST(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const apiKeyModuleService: IApiKeyModuleService = request.scope.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   const authenticatedToken = await apiKeyModuleService.authenticate(
@@ -235,14 +235,14 @@ export async function POST(request: Request, { params }: ContextType) {
     MedusaResponse,
   } from "@medusajs/medusa"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: AuthenticatedMedusaRequest,
   res: MedusaResponse
 ) {
   const apiKeyModuleService: IApiKeyModuleService = request.scope.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   const revokedKey = await apiKeyModuleService.revoke(request.params.id, {

www/apps/resources/app/commerce-modules/api-key/page.mdx

@@ -10,7 +10,7 @@ The API Key Module is the `@medusajs/api-key` NPM package that provides API-key-
 
 ## How to Use API Key Module's Service
 
-You can use the API Key Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.API_KEY` imported from `@medusajs/utils`.
+You can use the API Key Module's main service by resolving from the Medusa container the resource `Modules.API_KEY` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const apiKeyModuleService: IApiKeyModuleService = request.scope.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const apiKeyModuleService: IApiKeyModuleService = container.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   const apiKeys = await apiKeyModuleService.listApiKeys()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IApiKeyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const apiKeyModuleService: IApiKeyModuleService = container.resolve(
-    ModuleRegistrationName.API_KEY
+    Modules.API_KEY
   )
 
   const apiKeys = await apiKeyModuleService.listApiKeys()

www/apps/resources/app/commerce-modules/auth/examples/page.mdx

@@ -25,7 +25,7 @@ This example uses the [jsonwebtoken NPM package](https://www.npmjs.com/package/j
     IAuthModuleService,
     AuthenticationInput,
   } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
   import { MedusaError } from "@medusajs/utils"
   import jwt from "jsonwebtoken"
 
@@ -34,7 +34,7 @@ export async function POST(
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   const { success, authIdentity, location, error } =
@@ -128,7 +128,7 @@ This example uses the [jsonwebtoken NPM package](https://www.npmjs.com/package/j
     IAuthModuleService,
     AuthenticationInput,
   } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
   import { MedusaError } from "@medusajs/utils"
   import jwt from "jsonwebtoken"
 
@@ -137,7 +137,7 @@ export async function POST(
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   const { success, authIdentity, error, successRedirectUrl } =
@@ -227,14 +227,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IAuthModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   const authIdentity = await authModuleService.createAuthIdentities({
@@ -283,14 +283,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IAuthModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   res.json({
@@ -329,14 +329,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IAuthModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   const authIdentity = await authModuleService.updateAuthIdentites({
@@ -395,14 +395,14 @@ export async function POST(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IAuthModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   await authModuleService.deleteAuthIdentities(["authusr_123"])

www/apps/resources/app/commerce-modules/auth/page.mdx

@@ -10,7 +10,7 @@ The Auth Module is the `@medusajs/auth` NPM package that provides authentication
 
 ## How to Use Auth Module's Service
 
-You can use the Auth Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.AUTH` imported from `@medusajs/utils`.
+You can use the Auth Module's main service by resolving from the Medusa container the resource `Modules.AUTH` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
 ```ts title="src/api/store/custom/route.ts"
 import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
 import { IAuthModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const authModuleService: IAuthModuleService = req.scope.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
 ```ts title="src/subscribers/custom-handler.ts"
 import { SubscriberArgs } from "@medusajs/medusa"
 import { IAuthModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const authModuleService: IAuthModuleService = container.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
 
   const authIdentitys = await authModuleService.listAuthIdentities()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
 ```ts title="src/workflows/hello-world/step1.ts"
 import { createStep } from "@medusajs/workflows-sdk"
 import { IAuthModuleService } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const authModuleService: IAuthModuleService = container.resolve(
-    ModuleRegistrationName.AUTH
+    Modules.AUTH
   )
   const authIdentitys = await authModuleService.listAuthIdentities()
 })

www/apps/resources/app/commerce-modules/cart/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Cart Module
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const cart = await cartModuleService.createCarts({
@@ -90,14 +90,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const cart = await cartModuleService.retrieveCart("cart_123")
@@ -138,14 +138,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const lineItem = await cartModuleService.addLineItems({
@@ -198,14 +198,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const shippingMethod = await cartModuleService.addShippingMethods({
@@ -256,14 +256,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const itemAdjustment = await cartModuleService.addLineItemAdjustments({
@@ -314,14 +314,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const shippingMethodAdjustment =
@@ -374,14 +374,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   await cartModuleService.deleteLineItems(["cali_123"])
@@ -418,14 +418,14 @@ export async function DELETE(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   await cartModuleService.deleteShippingMethods(["casm_123"])
@@ -440,14 +440,14 @@ export async function DELETE(
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   await cartModuleService.deleteShippingMethods(["casm_123"])

www/apps/resources/app/commerce-modules/cart/page.mdx

@@ -10,7 +10,7 @@ The Cart Module is the `@medusajs/cart` NPM package that provides cart-related f
 
 ## How to Use Cart Module's Service
 
-You can use the Cart Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.CART` imported from `@medusajs/utils`.
+You can use the Cart Module's main service by resolving from the Medusa container the resource `Modules.CART` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const cartModuleService: ICartModuleService = req.scope.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const cartModuleService: ICartModuleService = container.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const carts = await cartModuleService.listCarts()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { ICartModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const cartModuleService: ICartModuleService = container.resolve(
-    ModuleRegistrationName.CART
+    Modules.CART
   )
 
   const carts = await cartModuleService.listCarts()

www/apps/resources/app/commerce-modules/currency/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Currency Mod
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICurrencyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const currencyModuleService: ICurrencyModuleService = req.scope.resolve(
-    ModuleRegistrationName.CURRENCY
+    Modules.CURRENCY
   )
 
   res.json({
@@ -62,14 +62,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICurrencyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const currencyModuleService: ICurrencyModuleService = req.scope.resolve(
-    ModuleRegistrationName.CURRENCY
+    Modules.CURRENCY
   )
 
   const currency = await currencyModuleService.retrieveCurrency("usd")

www/apps/resources/app/commerce-modules/currency/page.mdx

@@ -10,7 +10,7 @@ The Currency Module is the `@medusajs/currency` NPM package that provides curren
 
 ## How to Use Currency Module's Service
 
-You can use the Currency Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.CURRENCY` imported from `@medusajs/utils`.
+You can use the Currency Module's main service by resolving from the Medusa container the resource `Modules.CURRENCY` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICurrencyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const currencyModuleService: ICurrencyModuleService = req.scope.resolve(
-    ModuleRegistrationName.CURRENCY
+    Modules.CURRENCY
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { ICurrencyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const currencyModuleService: ICurrencyModuleService = container.resolve(
-    ModuleRegistrationName.CURRENCY
+    Modules.CURRENCY
   )
 
   const currencies = await currencyModuleService.listCurrencies()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { ICurrencyModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const currencyModuleService: ICurrencyModuleService = container.resolve(
-    ModuleRegistrationName.CURRENCY
+    Modules.CURRENCY
   )
 
   const currencies = await currencyModuleService.listCurrencies()

www/apps/resources/app/commerce-modules/customer/examples/page.mdx

@@ -16,11 +16,11 @@ In this guide, you’ll find common examples of how you can use the Customer Mod
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const customerModuleService: ICustomerModuleService = request.scope.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   const customer = await customerModuleService.createCustomers({
@@ -71,11 +71,11 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const customerModuleService: ICustomerModuleService = request.scope.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   const customerGroup = await customerModuleService.createCustomerGroups({
@@ -122,11 +122,11 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const customerModuleService: ICustomerModuleService = request.scope.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   await customerModuleService.addCustomerToGroup({
@@ -171,11 +171,11 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const customerModuleService: ICustomerModuleService = request.scope.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   await customerModuleService.removeCustomerFromGroup({

www/apps/resources/app/commerce-modules/customer/page.mdx

@@ -10,7 +10,7 @@ The Customer Module is the `@medusajs/customer` NPM package that provides custom
 
 ## How to Use Customer Module's Service
 
-You can use the Customer Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.CUSTOMER` imported from `@medusajs/utils`.
+You can use the Customer Module's main service by resolving from the Medusa container the resource `Modules.CUSTOMER` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,11 +20,11 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(request: MedusaRequest, res: MedusaResponse) {
   const customerModuleService: ICustomerModuleService = request.scope.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   res.json({
@@ -39,11 +39,11 @@ export async function GET(request: MedusaRequest, res: MedusaResponse) {
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const customerModuleService: ICustomerModuleService = container.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   const customers = await customerModuleService.listCustomers()
@@ -56,11 +56,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { ICustomerModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const customerModuleService: ICustomerModuleService = container.resolve(
-    ModuleRegistrationName.CUSTOMER
+    Modules.CUSTOMER
   )
 
   const customers = await customerModuleService.listCustomers()

www/apps/resources/app/commerce-modules/fulfillment/page.mdx

@@ -10,7 +10,7 @@ The Fulfillment Module is the `@medusajs/fulfillment` NPM package that provides
 
 ## How to Use Fulfillment Module's Service
 
-You can use the Fulfillment Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.API_KEY` imported from `@medusajs/utils`.
+You can use the Fulfillment Module's main service by resolving from the Medusa container the resource `Modules.API_KEY` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IFulfillmentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const fulfillmentModuleService: IFulfillmentModuleService = req.scope.resolve(
-    ModuleRegistrationName.FULFILLMENT
+    Modules.FULFILLMENT
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IFulfillmentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const fulfillmentModuleService: IFulfillmentModuleService = container.resolve(
-    ModuleRegistrationName.FULFILLMENT
+    Modules.FULFILLMENT
   )
 
   const fulfillments = await fulfillmentModuleService.listFulfillments()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IFulfillmentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const fulfillmentModuleService: IFulfillmentModuleService = container.resolve(
-    ModuleRegistrationName.FULFILLMENT
+    Modules.FULFILLMENT
   )
 
   const fulfillments = await fulfillmentModuleService.listFulfillments()

www/apps/resources/app/commerce-modules/inventory/examples/page.mdx

@@ -16,14 +16,14 @@ In this document, you’ll find common examples of how you can use the Inventory
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryItem = await inventoryModuleService.createInventoryItems({
@@ -71,14 +71,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryItems = await inventoryModuleService.listInventoryItems({})
@@ -117,14 +117,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryItem = await inventoryModuleService.retrieveInventoryItem(
@@ -173,14 +173,14 @@ export async function GET(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryLevel = await inventoryModuleService.createInventoryLevels({
@@ -228,14 +228,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryLevel = await inventoryModuleService.adjustInventory(
@@ -283,14 +283,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   res.json({
@@ -338,14 +338,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const reservationItem = await inventoryModuleService.createReservationItems({
@@ -395,14 +395,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const reservedQuantity =
@@ -482,14 +482,14 @@ export async function POST(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   await inventoryModuleService.deleteReservationItems([

www/apps/resources/app/commerce-modules/inventory/page.mdx

@@ -10,7 +10,7 @@ The Inventory Module is the `@medusajs/inventory-next` NPM package that provides
 
 ## How to Use Inventory Module's Service
 
-You can use the Inventory Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.INVENTORY` imported from `@medusajs/utils`.
+You can use the Inventory Module's main service by resolving from the Medusa container the resource `Modules.INVENTORY` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const inventoryModuleService: IInventoryService = request.scope.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const inventoryModuleService: IInventoryService = container.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryItems = await inventoryModuleService.listInventoryItems({})
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IInventoryService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const inventoryModuleService: IInventoryService = container.resolve(
-    ModuleRegistrationName.INVENTORY
+    Modules.INVENTORY
   )
 
   const inventoryItems = await inventoryModuleService.listInventoryItems({})

www/apps/resources/app/commerce-modules/order/page.mdx

@@ -10,7 +10,7 @@ The Order Module is the `@medusajs/order` NPM package that provides order-relate
 
 ## How to Use Order Module's Service
 
-You can use the Order Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.ORDER` imported from `@medusajs/utils`.
+You can use the Order Module's main service by resolving from the Medusa container the resource `Modules.ORDER` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IOrderModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const orderModuleService: IOrderModuleService = req.scope.resolve(
-    ModuleRegistrationName.ORDER
+    Modules.ORDER
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IOrderModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const orderModuleService: IOrderModuleService = container.resolve(
-    ModuleRegistrationName.ORDER
+    Modules.ORDER
   )
 
   const orders = await orderModuleService.listOrders()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IOrderModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const orderModuleService: IOrderModuleService = container.resolve(
-    ModuleRegistrationName.ORDER
+    Modules.ORDER
   )
   const orders = await orderModuleService.listOrders()
 })

www/apps/resources/app/commerce-modules/payment/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Payment Modu
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const paymentCollection = await paymentModuleService.createPaymentCollections(
@@ -78,14 +78,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const paymentSession = await paymentModuleService.createPaymentSession(
@@ -144,14 +144,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const paymentSessions = await paymentModuleService.listPaymentSessions({
@@ -198,14 +198,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const payment = await paymentModuleService.authorizePaymentSession(
@@ -254,14 +254,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const payments = await paymentModuleService.listPayments({
@@ -308,14 +308,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const payment = await paymentModuleService.capturePayment({

www/apps/resources/app/commerce-modules/payment/page.mdx

@@ -11,7 +11,7 @@ The Payment Module is the `@medusajs/payment` NPM package that provides payment-
 
 ## How to Use Payment Module's Service
 
-You can use the Payment Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.PAYMENT` imported from `@medusajs/utils`.
+You can use the Payment Module's main service by resolving from the Medusa container the resource `Modules.PAYMENT` imported from `@medusajs/utils`.
 
 For example:
 
@@ -21,14 +21,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const paymentModuleService: IPaymentModuleService = req.scope.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   res.json({
@@ -43,11 +43,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const paymentModuleService: IPaymentModuleService = container.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const payment_collections =
@@ -61,11 +61,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IPaymentModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const paymentModuleService: IPaymentModuleService = container.resolve(
-    ModuleRegistrationName.PAYMENT
+    Modules.PAYMENT
   )
 
   const payment_collections =

www/apps/resources/app/commerce-modules/pricing/examples/page.mdx

@@ -16,14 +16,14 @@ In this document, you’ll find common examples of how you can use the Pricing M
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceSet = await pricingModuleService.createPriceSets([
@@ -87,14 +87,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceSets = await pricingModuleService.listPriceSets()
@@ -133,14 +133,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceSet = await pricingModuleService.retrievePriceSet("pset_123")
@@ -179,14 +179,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceSet = await pricingModuleService.addPrices({
@@ -249,14 +249,14 @@ export async function POST(request: Request) {
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
   import { PriceListType } from "@medusajs/utils"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceLists = await pricingModuleService.createPriceLists([
@@ -333,14 +333,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const price = await pricingModuleService.calculatePrices(

www/apps/resources/app/commerce-modules/pricing/page.mdx

@@ -10,7 +10,7 @@ The Pricing Module is the `@medusajs/pricing` NPM package that provides pricing-
 
 ## How to Use Pricing Module's Service
 
-You can use the Pricing Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.PRICING` imported from `@medusajs/utils`.
+You can use the Pricing Module's main service by resolving from the Medusa container the resource `Modules.PRICING` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const pricingModuleService: IPricingModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const pricingModuleService: IPricingModuleService = container.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceSets = await pricingModuleService.listPriceSets()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IPricingModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const pricingModuleService: IPricingModuleService = container.resolve(
-    ModuleRegistrationName.PRICING
+    Modules.PRICING
   )
 
   const priceSets = await pricingModuleService.listPriceSets()

www/apps/resources/app/commerce-modules/product/examples/page.mdx

@@ -16,11 +16,11 @@ In this guide, you’ll find common examples of how you can use the Product Modu
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const products = await productModuleService.createProducts([
@@ -97,11 +97,11 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const products = await productModuleService.listProducts()
@@ -140,11 +140,11 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const product = await productModuleService.retrieveProduct(request.params.id)
@@ -187,11 +187,11 @@ export async function GET(
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const data = await productModuleService.listProducts({
@@ -234,11 +234,11 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const categories = await productModuleService.listProductCategories()
@@ -277,11 +277,11 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const data = await productModuleService.listProductCategories({

www/apps/resources/app/commerce-modules/product/guides/price-with-taxes/page.mdx

@@ -20,14 +20,14 @@ You'll need the following resources for the taxes calculation:
 ```ts
 // other imports...
 import {
-  ModuleRegistrationName,
+  Modules,
   ContainerRegistrationKeys,
 } from "@medusajs/utils"
 
 // In an API route, workflow step, etc...
 const query = container.resolve(ContainerRegistrationKeys.QUERY)
 const taxModuleService = container.resolve(
-  ModuleRegistrationName.TAX
+  Modules.TAX
 )
 ```
 

www/apps/resources/app/commerce-modules/product/page.mdx

@@ -10,7 +10,7 @@ The Product Module is the `@medusajs/product` NPM package that provides product-
 
 ## How to Use Product Module's Service
 
-You can use the Product Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.PRODUCT` imported from `@medusajs/utils`.
+You can use the Product Module's main service by resolving from the Medusa container the resource `Modules.PRODUCT` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,11 +20,11 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(request: MedusaRequest, res: MedusaResponse) {
   const productModuleService: IProductModuleService = request.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   res.json({
@@ -39,11 +39,11 @@ export async function GET(request: MedusaRequest, res: MedusaResponse) {
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const productModuleService: IProductModuleService = container.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const products = await productModuleService.listProducts()
@@ -56,11 +56,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IProductModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const productModuleService: IProductModuleService = container.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   const products = await productModuleService.listProducts()

www/apps/resources/app/commerce-modules/promotion/examples/page.mdx

@@ -16,14 +16,14 @@ In this document, you’ll find common examples of how you can use the Promotion
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const promotionModuleService: IPromotionModuleService = request.scope.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   const promotion = await promotionModuleService.createPromotions({
@@ -81,14 +81,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const promotionModuleService: IPromotionModuleService = request.scope.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   const campaign = await promotionModuleService.createCampaigns({
@@ -138,14 +138,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const promotionModuleService: IPromotionModuleService = request.scope.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   const promotion = await promotionModuleService.createPromotions({
@@ -216,14 +216,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const promotionModuleService: IPromotionModuleService = request.scope.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   res.json({

www/apps/resources/app/commerce-modules/promotion/page.mdx

@@ -10,7 +10,7 @@ The Promotion Module is the `@medusajs/promotion` NPM package that provides prom
 
 ## How to Use the Promotion Module's Service
 
-You can use the Promotion Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.PROMOTION` imported from `@medusajs/utils`.
+You can use the Promotion Module's main service by resolving from the Medusa container the resource `Modules.PROMOTION` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const promotionModuleService: IPromotionModuleService = request.scope.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const promotionModuleService: IPromotionModuleService = container.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   const promotions = await promotionModuleService.listPromotions()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IPromotionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const promotionModuleService: IPromotionModuleService = container.resolve(
-    ModuleRegistrationName.PROMOTION
+    Modules.PROMOTION
   )
 
   const promotions = await promotionModuleService.listPromotions()

www/apps/resources/app/commerce-modules/region/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Region Modul
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const regionModuleService: IRegionModuleService = req.scope.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   const region = await regionModuleService.createRegions({
@@ -72,14 +72,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const regionModuleService: IRegionModuleService = req.scope.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   res.json({
@@ -118,14 +118,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const regionModuleService: IRegionModuleService = req.scope.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   const region = await regionModuleService.retrieveRegion("reg_123")
@@ -164,14 +164,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const regionModuleService: IRegionModuleService = req.scope.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   const region = await regionModuleService.updateRegions("reg_123", {
@@ -214,14 +214,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const regionModuleService: IRegionModuleService = req.scope.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   await regionModuleService.deleteRegions("reg_123")

www/apps/resources/app/commerce-modules/region/page.mdx

@@ -10,7 +10,7 @@ The Region Module is the `@medusajs/region` NPM package that provides region-rel
 
 ## How to Use Region Module's Service
 
-You can use the Region Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.REGION` imported from `@medusajs/utils`.
+You can use the Region Module's main service by resolving from the Medusa container the resource `Modules.REGION` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const regionModuleService: IRegionModuleService = req.scope.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const regionModuleService: IRegionModuleService = container.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   const regions = await regionModuleService.listRegions()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IRegionModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const regionModuleService: IRegionModuleService = container.resolve(
-    ModuleRegistrationName.REGION
+    Modules.REGION
   )
 
   const regions = await regionModuleService.listRegions()

www/apps/resources/app/commerce-modules/sales-channel/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Sales Channe
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const salesChannelModuleService: ISalesChannelModuleService =
-    request.scope.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    request.scope.resolve(Modules.SALES_CHANNEL)
 
   const salesChannel = await salesChannelModuleService.createSalesChannels({
     name: "B2B",
@@ -67,14 +67,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const salesChannelModuleService: ISalesChannelModuleService =
-    request.scope.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    request.scope.resolve(Modules.SALES_CHANNEL)
 
   res.json({
     sales_channels: salesChannelModuleService.listSalesChannels(),
@@ -112,14 +112,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const salesChannelModuleService: ISalesChannelModuleService =
-    request.scope.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    request.scope.resolve(Modules.SALES_CHANNEL)
 
   const salesChannel = await salesChannelModuleService.retrieveSalesChannel(
     "sc_123"
@@ -163,14 +163,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const salesChannelModuleService: ISalesChannelModuleService =
-    request.scope.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    request.scope.resolve(Modules.SALES_CHANNEL)
 
   const salesChannel = await salesChannelModuleService.updateSalesChannels({
     id: "sc_123",
@@ -216,14 +216,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const salesChannelModuleService: ISalesChannelModuleService =
-    request.scope.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    request.scope.resolve(Modules.SALES_CHANNEL)
 
   await salesChannelModuleService.deleteSalesChannels("sc_123")
 

www/apps/resources/app/commerce-modules/sales-channel/page.mdx

@@ -10,7 +10,7 @@ The Sales Channel Module is the `@medusajs/sales-channel` NPM package that provi
 
 ## How to Use Sales Channel Module's Service
 
-You can use the Sales Channel Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.SALES_CHANNEL` imported from `@medusajs/utils`.
+You can use the Sales Channel Module's main service by resolving from the Medusa container the resource `Modules.SALES_CHANNEL` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const salesChannelModuleService: ISalesChannelModuleService =
-    request.scope.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    request.scope.resolve(Modules.SALES_CHANNEL)
 
   res.json({
     sales_channels: await salesChannelModuleService.listSalesChannels(),
@@ -41,11 +41,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const salesChannelModuleService: ISalesChannelModuleService =
-    container.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    container.resolve(Modules.SALES_CHANNEL)
 
   const salesChannels = await salesChannelModuleService.listSalesChannels()
 }
@@ -57,11 +57,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { ISalesChannelModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const salesChannelModuleService: ISalesChannelModuleService =
-    container.resolve(ModuleRegistrationName.SALES_CHANNEL)
+    container.resolve(Modules.SALES_CHANNEL)
 
   const salesChannels = await salesChannelModuleService.listSalesChannels()
 })

www/apps/resources/app/commerce-modules/stock-location/examples/page.mdx

@@ -16,14 +16,14 @@ In this document, you’ll find common examples of how you can use the Stock Loc
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const stockLocationModuleService: IStockLocationService =
-    request.scope.resolve(ModuleRegistrationName.STOCK_LOCATION)
+    request.scope.resolve(Modules.STOCK_LOCATION)
 
   const stockLocation = await stockLocationModuleService.createStockLocations({
     name: "Warehouse 1",
@@ -67,14 +67,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const stockLocationModuleService: IStockLocationService =
-    request.scope.resolve(ModuleRegistrationName.STOCK_LOCATION)
+    request.scope.resolve(Modules.STOCK_LOCATION)
 
   res.json({
     stock_locations: await stockLocationModuleService.listStockLocations({}),
@@ -112,14 +112,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const stockLocationModuleService: IStockLocationService =
-    request.scope.resolve(ModuleRegistrationName.STOCK_LOCATION)
+    request.scope.resolve(Modules.STOCK_LOCATION)
 
   const stockLocation = await stockLocationModuleService.updateStockLocations({
     id: "sloc_123",
@@ -177,14 +177,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const stockLocationModuleService: IStockLocationService =
-    request.scope.resolve(ModuleRegistrationName.STOCK_LOCATION)
+    request.scope.resolve(Modules.STOCK_LOCATION)
 
   await stockLocationModuleService.deleteStockLocations("sloc_123")
 

www/apps/resources/app/commerce-modules/stock-location/page.mdx

@@ -10,7 +10,7 @@ The Stock Location Module is the `@medusajs/stock-location-next` NPM package tha
 
 ## How to Use Stock Location Module's Service
 
-You can use the Stock Location Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.STOCK_LOCATION` imported from `@medusajs/utils`.
+You can use the Stock Location Module's main service by resolving from the Medusa container the resource `Modules.STOCK_LOCATION` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const stockLocationModuleService: IStockLocationService =
-    request.scope.resolve(ModuleRegistrationName.STOCK_LOCATION)
+    request.scope.resolve(Modules.STOCK_LOCATION)
 
   res.json({
     stock_locations: await stockLocationModuleService.listStockLocations({}),
@@ -41,11 +41,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const stockLocationModuleService: IStockLocationService = container.resolve(
-    ModuleRegistrationName.STOCK_LOCATION
+    Modules.STOCK_LOCATION
   )
 
   const stockLocations = await stockLocationModuleService.listStockLocations({})
@@ -58,11 +58,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IStockLocationService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const stockLocationModuleService: IStockLocationService = container.resolve(
-    ModuleRegistrationName.STOCK_LOCATION
+    Modules.STOCK_LOCATION
   )
 
   const stockLocations = await stockLocationModuleService.listStockLocations({})

www/apps/resources/app/commerce-modules/store/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Store Module
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const storeModuleService: IStoreModuleService = request.scope.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   const store = await storeModuleService.createStores({
@@ -82,14 +82,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const storeModuleService: IStoreModuleService = request.scope.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   res.json({
@@ -130,14 +130,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const storeModuleService: IStoreModuleService = request.scope.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   const store = await storeModuleService.retrieveStore("store_123")
@@ -178,14 +178,14 @@ export async function GET(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const storeModuleService: IStoreModuleService = request.scope.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   const store = await storeModuleService.updateStores("store_123", {
@@ -230,14 +230,14 @@ export async function POST(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const storeModuleService: IStoreModuleService = request.scope.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   await storeModuleService.deleteStores("store_123")

www/apps/resources/app/commerce-modules/store/page.mdx

@@ -10,7 +10,7 @@ The Store Module is the `@medusajs/store` NPM package that provides store-relate
 
 ## How to Use Store Module's Service
 
-You can use the Store Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.STORE` imported from `@medusajs/utils`.
+You can use the Store Module's main service by resolving from the Medusa container the resource `Modules.STORE` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   request: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const storeModuleService: IStoreModuleService = request.scope.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const storeModuleService: IStoreModuleService = container.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   const stores = await storeModuleService.listStores()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IStoreModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const storeModuleService: IStoreModuleService = container.resolve(
-    ModuleRegistrationName.STORE
+    Modules.STORE
   )
 
   const stores = await storeModuleService.listStores()

www/apps/resources/app/commerce-modules/tax/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the Tax Module i
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const taxModuleService: ITaxModuleService = req.scope.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   const taxRegion = await taxModuleService.createTaxRegions({
@@ -78,14 +78,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const taxModuleService: ITaxModuleService = req.scope.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   res.json({
@@ -124,14 +124,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const taxModuleService: ITaxModuleService = req.scope.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   const taxRate = await taxModuleService.createTaxRates({
@@ -202,14 +202,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const taxModuleService: ITaxModuleService = req.scope.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   res.json({
@@ -248,14 +248,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const taxModuleService: ITaxModuleService = req.scope.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   const taxLines = await taxModuleService.getTaxLines(

www/apps/resources/app/commerce-modules/tax/page.mdx

@@ -10,7 +10,7 @@ The Tax Module is the `@medusajs/tax` NPM package that provides tax-related feat
 
 ## How to Use Tax Module's Service
 
-You can use the Tax Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.TAX` imported from `@medusajs/utils`.
+You can use the Tax Module's main service by resolving from the Medusa container the resource `Modules.TAX` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const taxModuleService: ITaxModuleService = req.scope.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const taxModuleService: ITaxModuleService = container.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   const taxRegions = await taxModuleService.listTaxRegions()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { ITaxModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const taxModuleService: ITaxModuleService = container.resolve(
-    ModuleRegistrationName.TAX
+    Modules.TAX
   )
 
   const taxRegions = await taxModuleService.listTaxRegions()

www/apps/resources/app/commerce-modules/user/examples/page.mdx

@@ -16,14 +16,14 @@ In this guide, you’ll find common examples of how you can use the User Module
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const user = await userModuleService.createUsers({
@@ -72,14 +72,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   res.json({
@@ -118,14 +118,14 @@ export async function GET(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const user = await userModuleService.updateUsers({
@@ -172,14 +172,14 @@ export async function POST(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function DELETE(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   await userModuleService.deleteUsers(["user_123"])
@@ -214,14 +214,14 @@ export async function DELETE(request: Request) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const invite = await userModuleService.createInvites({
@@ -268,14 +268,14 @@ export async function POST(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const invite = await userModuleService.validateInviteToken("secret_123")
@@ -338,14 +338,14 @@ export async function POST(request: Request, { params }: ContextType) {
   ```ts
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function POST(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const invites = await userModuleService.refreshInviteTokens(["invite_123"])

www/apps/resources/app/commerce-modules/user/page.mdx

@@ -10,7 +10,7 @@ The User Module is the `@medusajs/user` NPM package that provides user-related f
 
 ## How to Use User Module's Service
 
-You can use the User Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.USER` imported from `@medusajs/utils`.
+You can use the User Module's main service by resolving from the Medusa container the resource `Modules.USER` imported from `@medusajs/utils`.
 
 For example:
 
@@ -20,14 +20,14 @@ For example:
   ```ts title="src/api/store/custom/route.ts"
   import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export async function GET(
   req: MedusaRequest,
   res: MedusaResponse
 ): Promise<void> {
   const userModuleService: IUserModuleService = req.scope.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   res.json({
@@ -42,11 +42,11 @@ export async function GET(
   ```ts title="src/subscribers/custom-handler.ts"
   import { SubscriberArgs } from "@medusajs/medusa"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 export default async function subscriberHandler({ container }: SubscriberArgs) {
   const userModuleService: IUserModuleService = container.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const users = await userModuleService.listUsers()
@@ -59,11 +59,11 @@ export default async function subscriberHandler({ container }: SubscriberArgs) {
   ```ts title="src/workflows/hello-world/step1.ts"
   import { createStep } from "@medusajs/workflows-sdk"
   import { IUserModuleService } from "@medusajs/types"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
 
 const step1 = createStep("step-1", async (_, { container }) => {
   const userModuleService: IUserModuleService = container.resolve(
-    ModuleRegistrationName.USER
+    Modules.USER
   )
 
   const users = await userModuleService.listUsers()

www/apps/resources/app/medusa-container-resources/page.mdx

@@ -122,7 +122,7 @@ Use the `ContainerRegistrationKeys` enum imported from `@medusajs/utils` to reso
       <Table.Cell>
 
       - For custom modules, the registration name is the key of the module in the `modules` configuration.
-      - For Medusa's commerce modules, you can use the `ModuleRegistrationName` enum imported from `@medusajs/utils`.
+      - For Medusa's commerce modules, you can use the `Modules` enum imported from `@medusajs/utils`.
 
       </Table.Cell>
     </Table.Row>

www/apps/resources/app/recipes/b2b/page.mdx

@@ -609,7 +609,7 @@ export const checkCustomerHighlights = [
     AuthenticatedMedusaRequest, 
     MedusaResponse,
   } from "@medusajs/medusa"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
   import { ICustomerModuleService } from "@medusajs/types"
   import B2bModuleService from "../../../../modules/b2b/service"
   
@@ -618,7 +618,7 @@ export const checkCustomerHighlights = [
     res: MedusaResponse
   ) {
     const customerModuleService: ICustomerModuleService = req
-      .scope.resolve(ModuleRegistrationName.CUSTOMER)
+      .scope.resolve(Modules.CUSTOMER)
     const b2bModuleService: B2bModuleService = req.scope.resolve(
       "b2bModuleService"
     )

www/apps/resources/app/recipes/commerce-automation/page.mdx

@@ -461,7 +461,7 @@ export const syncProductsWorkflowHighlight = [
 
   ```ts title="src/workflows/sync-products.ts" highlights={syncProductsWorkflowHighlight} collapsibleLines="1-16" expandButtonLabel="Show Imports"
   import { 
-    ModuleRegistrationName
+    Modules
   } from "@medusajs/utils"
   import { 
     IProductModuleService, 
@@ -483,7 +483,7 @@ export const syncProductsWorkflowHighlight = [
     "retrieve-store-step",
     async ({ id }: RetrieveStoreStepInput, { container }) => {
       const storeModuleService: IStoreModuleService = 
-        container.resolve(ModuleRegistrationName.STORE)
+        container.resolve(Modules.STORE)
 
       const store = await storeModuleService.retrieveStore(id)
 
@@ -499,7 +499,7 @@ export const syncProductsWorkflowHighlight = [
     "retrieve-products-to-update-step",
     async ({ last_sync_date }: RetrieveProductsToUpdateStepInput, { container }) => {
       const productModuleService: IProductModuleService = 
-        container.resolve(ModuleRegistrationName.PRODUCT)
+        container.resolve(Modules.PRODUCT)
 
       const products = await productModuleService.listProducts({
         updated_at: {
@@ -553,7 +553,7 @@ export const syncProductsWorkflowHighlight = [
     "update-store-last-sync-step",
     async ({ store }: UpdateStoreLastSyncStepInput, { container }) => {
       const storeModuleService: IStoreModuleService = 
-        container.resolve(ModuleRegistrationName.STORE)
+        container.resolve(Modules.STORE)
 
       const prevLastSyncDate = store.metadata.last_sync_date
 
@@ -570,7 +570,7 @@ export const syncProductsWorkflowHighlight = [
     },
     async ({ id, last_sync_date }, { container }) => {
       const storeModuleService: IStoreModuleService = 
-        container.resolve(ModuleRegistrationName.STORE)
+        container.resolve(Modules.STORE)
 
       await storeModuleService.updateStores(id, {
         metadata: {
@@ -764,7 +764,7 @@ The `order.placed` event is currently not emitted.
     SubscriberConfig,
   } from "@medusajs/medusa"
   import { 
-    ModuleRegistrationName,
+    Modules,
   } from "@medusajs/utils"
   import { 
     ICustomerModuleService, 
@@ -778,11 +778,11 @@ The `order.placed` event is currently not emitted.
     const orderId = data.id
 
     const orderModuleService: IOrderModuleService = container
-      .resolve(ModuleRegistrationName.ORDER)
+      .resolve(Modules.ORDER)
 
     const customerModuleService: 
       ICustomerModuleService = container.resolve(
-        ModuleRegistrationName.CUSTOMER
+        Modules.CUSTOMER
       )
 
     // check if VIP group exists
@@ -878,7 +878,7 @@ export const newsletterHighlights = [
     SubscriberConfig,
   } from "@medusajs/medusa"
   import { 
-    ModuleRegistrationName,
+    Modules,
   } from "@medusajs/utils"
   import { 
     ICustomerModuleService, 
@@ -891,17 +891,17 @@ export const newsletterHighlights = [
     container,
   }: SubscriberArgs<{ id: string }>) {
     const productModuleService: IProductModuleService = 
-      container.resolve(ModuleRegistrationName.PRODUCT)
+      container.resolve(Modules.PRODUCT)
 
     const storeModuleService: IStoreModuleService = 
-      container.resolve(ModuleRegistrationName.STORE)
+      container.resolve(Modules.STORE)
 
     const customerModuleService: ICustomerModuleService = 
-      container.resolve(ModuleRegistrationName.CUSTOMER)
+      container.resolve(Modules.CUSTOMER)
 
     const notificationModuleService:
       INotificationModuleService = container.resolve(
-        ModuleRegistrationName.NOTIFICATION
+        Modules.NOTIFICATION
       )
 
     const store = (await storeModuleService.listStores())[0]

www/apps/resources/app/recipes/digital-products/examples/standard/page.mdx

@@ -1841,7 +1841,7 @@ import {
   IFileModuleService,
 } from "@medusajs/types"
 import { 
-  ModuleRegistrationName,
+  Modules,
   ContainerRegistrationKeys,
 } from "@medusajs/utils"
 import { MediaType } from "../modules/digital-product/types"
@@ -1852,9 +1852,9 @@ async function digitalProductOrderCreatedHandler({
 }: SubscriberArgs<{ id: string }>) {
   const query = container.resolve(ContainerRegistrationKeys.QUERY)
   const notificationModuleService: INotificationModuleService = container
-    .resolve(ModuleRegistrationName.NOTIFICATION)
+    .resolve(Modules.NOTIFICATION)
   const fileModuleService: IFileModuleService = container.resolve(
-    ModuleRegistrationName.FILE
+    Modules.FILE
   )
 
   const { data: [digitalProductOrder] } = await query.graph({
@@ -1970,7 +1970,7 @@ import {
   MedusaResponse,
 } from "@medusajs/medusa"
 import {
-  ModuleRegistrationName,
+  Modules,
 } from "@medusajs/utils"
 import { 
   DIGITAL_PRODUCT_MODULE,
@@ -1985,7 +1985,7 @@ export const GET = async (
   res: MedusaResponse
 ) => {
   const fileModuleService = req.scope.resolve(
-    ModuleRegistrationName.FILE
+    Modules.FILE
   )
 
   const digitalProductModuleService: DigitalProductModuleService = 
@@ -2094,7 +2094,7 @@ import {
   MedusaResponse,
 } from "@medusajs/medusa"
 import { 
-  ModuleRegistrationName,
+  Modules,
   ContainerRegistrationKeys,
   MedusaError,
 } from "@medusajs/utils"
@@ -2104,7 +2104,7 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const fileModuleService = req.scope.resolve(
-    ModuleRegistrationName.FILE
+    Modules.FILE
   )
   const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
 

www/apps/resources/app/recipes/integrate-ecommerce-stack/page.mdx

@@ -182,7 +182,7 @@ export const workflowHighlights = [
       WorkflowResponse,
     } from "@medusajs/workflows-sdk"
     import { IProductModuleService } from "@medusajs/types"
-    import { ModuleRegistrationName } from "@medusajs/utils"
+    import { Modules } from "@medusajs/utils"
     import ErpModuleService from "../modules/erp/service"
 
     type WorkflowInput = {
@@ -200,7 +200,7 @@ export const workflowHighlights = [
         "erpModuleService"
       )
       const productModuleService: IProductModuleService = container
-        .resolve(ModuleRegistrationName.PRODUCT)
+        .resolve(Modules.PRODUCT)
       
       const createdProductData = await productModuleService
         .retrieveProduct(productId)
@@ -226,7 +226,7 @@ export const workflowHighlights = [
         "erpModuleService"
       )
       const productModuleService: IProductModuleService = container
-        .resolve(ModuleRegistrationName.PRODUCT)
+        .resolve(Modules.PRODUCT)
 
       await erpModuleService.deleteProduct(erpId)
       await productModuleService.updateProducts(productId, {
@@ -315,7 +315,7 @@ For example, suppose an administrator changes the product data in the ERP system
       UpdateProductDTO
     } from "@medusajs/types"
     import {
-      ModuleRegistrationName
+      Modules
     } from "@medusajs/utils"
 
     type WebhookReq = {
@@ -331,7 +331,7 @@ For example, suppose an administrator changes the product data in the ERP system
 
       const productService: IProductModuleService = req.scope
         .resolve(
-          ModuleRegistrationName.PRODUCT
+          Modules.PRODUCT
         )
 
       await productService.updateProducts(id, updatedData)

www/apps/resources/app/recipes/marketplace/examples/restaurant-delivery/page.mdx

@@ -1673,7 +1673,7 @@ export const notifyRestaurantStepHighlights = [
 
 ```ts title="src/workflows/delivery/steps/notify-restaurant.ts" highlights={notifyRestaurantStepHighlights} collapsibleLines="1-6" expandButtonLabel="Show Imports"
 import {
-  ModuleRegistrationName,
+  Modules,
   ContainerRegistrationKeys,
 } from "@medusajs/utils"
 import { createStep } from "@medusajs/workflows-sdk"
@@ -1699,7 +1699,7 @@ export const notifyRestaurantStep = createStep(
       fields: ["id", "restaurant.id"],
     })
 
-    const eventBus = container.resolve(ModuleRegistrationName.EVENT_BUS)
+    const eventBus = container.resolve(Modules.EVENT_BUS)
 
     await eventBus.emit({
       name: "notify.restaurant",
@@ -1760,7 +1760,6 @@ export const createOrderStepHighlights1 = [
 ```ts title="src/workflows/delivery/steps/create-order.ts" highlights={createOrderStepHighlights1} collapsibleLines="1-9" expandButtonLabel="Show Imports"
 import { CreateOrderShippingMethodDTO } from "@medusajs/types"
 import {
-  ModuleRegistrationName,
   Modules,
   ContainerRegistrationKeys,
 } from "@medusajs/utils"
@@ -1810,7 +1809,7 @@ export const createOrderStepHighlights2 = [
 ```ts title="src/workflows/delivery/steps/create-order.ts" highlights={createOrderStepHighlights2}
 const { cart } = delivery
 
-const orderModuleService = container.resolve(ModuleRegistrationName.ORDER)
+const orderModuleService = container.resolve(Modules.ORDER)
 
 const order = await orderModuleService.createOrders({
   currency_code: cart.currency_code,
@@ -1847,7 +1846,7 @@ You create the order using the Order Module’s main service. Then, you create a
 Then, replace the `TODO` in the compensation function with the following:
 
 ```ts title="src/workflows/delivery/steps/create-order.ts"
-const orderService = container.resolve(ModuleRegistrationName.ORDER)
+const orderService = container.resolve(Modules.ORDER)
 
 await orderService.softDeleteOrders([orderId])
 ```
@@ -1903,14 +1902,14 @@ export const createFulfillmentStepHighlights = [
 
 ```ts title="src/workflows/delivery/steps/create-fulfillment.ts" highlights={createFulfillmentStepHighlights}
 import { OrderDTO } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/utils"
+import { Modules } from "@medusajs/utils"
 import { StepResponse, createStep } from "@medusajs/workflows-sdk"
 
 export const createFulfillmentStep = createStep(
   "create-fulfillment-step",
   async function (order: OrderDTO, { container }) {
     const fulfillmentModuleService = container.resolve(
-      ModuleRegistrationName.FULFILLMENT
+      Modules.FULFILLMENT
     )
 
     const items = order.items?.map((lineItem) => ({
@@ -1934,7 +1933,7 @@ export const createFulfillmentStep = createStep(
   },
   function (id: string, { container }) {
     const fulfillmentModuleService = container.resolve(
-      ModuleRegistrationName.FULFILLMENT
+      Modules.FULFILLMENT
     )
 
     return fulfillmentModuleService.cancelFulfillment(id)
@@ -2345,7 +2344,7 @@ export const setStepSuccessStepHighlights = [
 
 ```ts title="src/workflows/delivery/steps/set-step-success.ts" highlights={setStepSuccessStepHighlights} collapsibleLines="1-8" expandButtonLabel="Show Imports"
 import {
-  ModuleRegistrationName,
+  Modules,
   TransactionHandlerType,
 } from "@medusajs/utils"
 import { StepResponse, createStep } from "@medusajs/workflows-sdk"
@@ -2364,7 +2363,7 @@ export const setStepSuccessStep = createStep(
     { container }
   ) {
     const engineService = container.resolve(
-      ModuleRegistrationName.WORKFLOW_ENGINE
+      Modules.WORKFLOW_ENGINE
     )
 
     await engineService.setStepSuccess({
@@ -2396,7 +2395,7 @@ export const setStepFailedStepHighlights = [
 
 ```ts title="src/workflows/delivery/steps/set-step-failed.ts" highlights={setStepFailedStepHighlights} collapsibleLines="1-8" expandButtonLabel="Show Imports"
 import {
-  ModuleRegistrationName,
+  Modules,
   TransactionHandlerType,
 } from "@medusajs/utils"
 import { StepResponse, createStep } from "@medusajs/workflows-sdk"
@@ -2415,7 +2414,7 @@ export const setStepFailedStep = createStep(
     { container }
   ) {
     const engineService = container.resolve(
-      ModuleRegistrationName.WORKFLOW_ENGINE
+      Modules.WORKFLOW_ENGINE
     )
 
     await engineService.setStepFailure({
@@ -3266,7 +3265,7 @@ import {
   MedusaResponse,
 } from "@medusajs/medusa"
 import {
-  ModuleRegistrationName,
+  Modules,
 } from "@medusajs/utils"
 import { 
   handleDeliveryWorkflowId,
@@ -3320,7 +3319,7 @@ To listen to the workflow changes, replace the new `TODO` with the following:
 
 ```ts title="src/api/store/deliveries/subscribe/route.ts"
 const workflowEngine = req.scope.resolve(
-  ModuleRegistrationName.WORKFLOW_ENGINE
+  Modules.WORKFLOW_ENGINE
 )
 
 const workflowSubHandler = (data: any) => {

www/apps/resources/app/recipes/marketplace/examples/vendors/page.mdx

@@ -624,7 +624,7 @@ import {
 } from "@medusajs/types"
 import { 
   Modules, 
-  ModuleRegistrationName,
+  Modules,
 } from "@medusajs/utils"
 
 // GET method...
@@ -639,9 +639,9 @@ export const POST = async (
   const marketplaceModuleService: MarketplaceModuleService = 
     req.scope.resolve(MARKETPLACE_MODULE)
   const productModuleService: IProductModuleService = req.scope
-    .resolve(ModuleRegistrationName.PRODUCT)
+    .resolve(Modules.PRODUCT)
   const salesChannelModuleService: ISalesChannelModuleService = req.scope
-    .resolve(ModuleRegistrationName.SALES_CHANNEL)
+    .resolve(Modules.SALES_CHANNEL)
   // Retrieve default sales channel to make the product available in.
   // Alternatively, you can link sales channels to vendors and allow vendors
   // to manage sales channels

www/apps/resources/app/recipes/pos/page.mdx

@@ -78,7 +78,7 @@ Here’s an example of creating a custom API Route at `/store/pos/search-barcode
     MedusaResponse, 
   } from "@medusajs/medusa"
   import { MedusaError } from "@medusajs/utils"
-  import { ModuleRegistrationName } from "@medusajs/utils"
+  import { Modules } from "@medusajs/utils"
   import { IProductModuleService } from "@medusajs/types"
 
 export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
@@ -88,7 +88,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   }
   // get product service
   const productModuleService: IProductModuleService = req.scope.resolve(
-    ModuleRegistrationName.PRODUCT
+    Modules.PRODUCT
   )
 
   // retrieve product variants by barcode

www/apps/resources/app/recipes/subscriptions/examples/standard/page.mdx

@@ -1495,7 +1495,6 @@ import {
 } from "@medusajs/types"
 import { 
   Modules,
-  ModuleRegistrationName,
 } from "@medusajs/utils"
 import { createOrdersWorkflow } from "@medusajs/core-flows"
 import { SubscriptionData } from "../../../modules/subscription/types"
@@ -1624,7 +1623,7 @@ Finally, replace the `TODO` in the compensation function to cancel the order in
 
 ```ts title="src/workflows/create-subscription-order/steps/create-subscription-order.ts"
 const orderModuleService: IOrderModuleService = container.resolve(
-  ModuleRegistrationName.ORDER
+  Modules.ORDER
 )
 
 await orderModuleService.cancel(order.id)