Core Resolution

/**
 * Main resolver class for Ember CLI applications
 */
class Resolver {
  /** Indicates this is a module-based resolver */
  static moduleBasedResolver: boolean;
  moduleBasedResolver: boolean;
  
  /** Cache for normalized module names */
  _normalizeCache: object;
  
  /** List of lookup pattern functions */
  moduleNameLookupPatterns: Function[];
  
  /** Mapping of type names to their pluralized forms */
  pluralizedTypes: Record<string, string>;
}

/**
 * Factory method to create resolver instances
 * @param props - Configuration properties for the resolver
 * @returns New resolver instance
 */
static create(props: object): Resolver;

/**
 * Creates resolver subclass with explicit module registry
 * @param explicitModules - Object mapping module names to implementations
 * @returns Resolver subclass with static modules
 */
static withModules(explicitModules: object): typeof Resolver;

import Resolver from "ember-resolver";

// Basic resolver creation
const resolver = Resolver.create({
  namespace: {
    modulePrefix: "my-app",
    podModulePrefix: "my-app/pods"
  }
});

// Static resolver with explicit modules
const StaticResolver = Resolver.withModules({
  "my-app/components/hello": HelloComponent,
  "my-app/routes/application": ApplicationRoute,
  "my-app/controllers/posts": PostsController
});

const staticResolver = StaticResolver.create();

/**
 * Main resolution method, resolves fullName to actual module
 * @param fullName - Ember fullName (e.g., "component:my-component")
 * @returns Resolved module or undefined
 */
resolve(fullName: string): any;

/**
 * Parses Ember fullName into structured object
 * @param fullName - Ember fullName to parse
 * @returns Structured representation of the name
 */
parseName(fullName: string): ParsedName;

/**
 * Normalizes fullName for consistent lookup
 * @param fullName - Ember fullName to normalize
 * @returns Normalized fullName
 */
normalize(fullName: string): string;

/**
 * Resolves non-specialized types using module lookup patterns
 * @param parsedName - Parsed name object
 * @returns Resolved module or undefined
 */
resolveOther(parsedName: ParsedName): any;

// Resolve a component
const MyComponent = resolver.resolve("component:user-profile");

// Parse a fullName
const parsed = resolver.parseName("route:posts/show");
console.log(parsed);
// Output: {
//   parsedName: true,
//   fullName: "route:posts/show",
//   type: "route",
//   name: "posts/show",
//   fullNameWithoutType: "posts/show",
//   prefix: "my-app",
//   resolveMethodName: "resolveRoute"
// }

// Normalize a fullName
const normalized = resolver.normalize("component:userProfile");
// Output: "component:user-profile"

/**
 * Resolves Ember engine modules
 * @param parsedName - Parsed name for engine
 * @returns Engine class or undefined
 */
resolveEngine(parsedName: ParsedName): any;

/**
 * Resolves Ember engine route maps
 * @param parsedName - Parsed name for route map
 * @returns Route map object or undefined
 */
resolveRouteMap(parsedName: ParsedName): any;

/**
 * Resolves template modules
 * @param parsedName - Parsed name for template
 * @returns Template function or undefined
 */
resolveTemplate(parsedName: ParsedName): any;

/**
 * Generates pod-based module names
 * @param parsedName - Parsed name object
 * @returns Pod-based module name
 */
podBasedModuleName(parsedName: ParsedName): string;

/**
 * Generates pod-based component module names in subdirectory
 * @param parsedName - Parsed name object
 * @returns Pod-based component module name
 */
podBasedComponentsInSubdir(parsedName: ParsedName): string;

/**
 * Generates main module names (for main resources like router:main)
 * @param parsedName - Parsed name object
 * @returns Main module name or undefined
 */
mainModuleName(parsedName: ParsedName): string;

/**
 * Generates default module names using pluralized types
 * @param parsedName - Parsed name object
 * @returns Default module name
 */
defaultModuleName(parsedName: ParsedName): string;

/**
 * Generates nested colocation component module names
 * @param parsedName - Parsed name object
 * @returns Nested component module name or undefined
 */
nestedColocationComponentModuleName(parsedName: ParsedName): string;

/**
 * Creates toString representation for factories
 * @param factory - Factory object
 * @param fullName - Ember fullName
 * @returns String representation
 */
makeToString(factory: any, fullName: string): string;

/**
 * Determines if module should be wrapped in class factory
 * @param module - Module to check
 * @param parsedName - Parsed name object
 * @returns Boolean indicating whether to wrap
 */
shouldWrapInClassFactory(module: any, parsedName: ParsedName): boolean;

/**
 * Pluralizes type names with caching
 * @param type - Type name to pluralize
 * @returns Pluralized type name
 */
pluralize(type: string): string;

/**
 * Gets prefix for parsed name based on type
 * @param parsedName - Parsed name object
 * @returns Module prefix
 */
prefix(parsedName: ParsedName): string;

/**
 * Finds actual module name using lookup patterns
 * @param parsedName - Parsed name object
 * @returns Found module name or undefined
 */
findModuleName(parsedName: ParsedName): string;

/**
 * Chooses between dashed/underscored module names
 * @param moduleName - Module name to resolve
 * @returns Chosen module name
 */
chooseModuleName(moduleName: string): string;

/**
 * Returns all known modules for a given type
 * @param type - Resource type (component, route, etc.)
 * @returns Object with module names as keys
 */
knownForType(type: string): object;

/**
 * Translates module name to container fullname
 * @param type - Resource type
 * @param moduleName - Module name to translate
 * @returns Container fullname or undefined
 */
translateToContainerFullname(type: string, moduleName: string): string;

/**
 * Adds modules to registry (only for static module resolvers)
 * @param modules - Object mapping module names to implementations
 */
addModules(modules: object): void;
/**
 * Pod-based lookup with custom prefix (internal utility)
 * @param podPrefix - Custom pod prefix to use
 * @param parsedName - Parsed name object
 * @returns Pod-based module name
 */
podBasedLookupWithPrefix(podPrefix: string, parsedName: ParsedName): string;

interface ParsedName {
  /** Flag indicating this is a parsed name object */
  parsedName: true;
  /** Original full name */
  fullName: string;
  /** Module prefix */
  prefix: string;
  /** Resource type (component, route, controller, etc.) */
  type: string;
  /** Name portion without type */
  fullNameWithoutType: string;
  /** Final name portion */
  name: string;
  /** Root namespace object */
  root: object;
  /** Method name for specialized resolution */
  resolveMethodName: string;
}