docs: replace ModuleRegistrationName with Modules (#9142)

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()