/**
 * Return a default shape (polygon) for the given dimensions,
 * or the existing shapes if already defined in settings.
 * @param {object} settings - TMX object settings
 * @returns {Polygon|object[]} shape(s) for the object body
 * @ignore
 */
export function getDefaultShape(settings: object): Polygon | object[];
/**
 * Detect the object type from its TMX settings.
 * The detection order is:
 * 1. TMXLayer instances → "layer" (passthrough)
 * 2. Object class matching a registered factory → class name
 * 3. Object name matching a registered factory → name
 * 4. Object with text data → "text"
 * 5. Object with tile/gid data → "tile"
 * 6. Everything else → "shape"
 * @param {object} settings - TMX object settings
 * @returns {string} the factory type key
 * @ignore
 */
export function detectObjectType(settings: object): string;
/**
 * Register a factory function for a given Tiled object type.
 * When a Tiled map is loaded, objects are matched to factories using the following
 * priority: object class → object name → structural type ("text", "tile", "shape").
 * <br><br>
 * Built-in structural types are: `"text"`, `"tile"`, `"shape"`.
 * Custom types are matched against the object's Tiled `class` or `name` property.
 * <br><br>
 * For simple cases where you just want to map a Tiled class to a constructor,
 * use {@link registerTiledObjectClass} instead.
 * @category Tilemap
 * @param {string} type - the object type key (built-in type or Tiled class/name)
 * @param {Function} factory - factory function with signature `(settings, map) => Renderable`
 * @example
 * // register a custom factory for "Spine" objects in Tiled
 * // (set the object class to "Spine" in Tiled, and add atlasFile/jsonFile custom properties)
 * registerTiledObjectFactory("Spine", (settings, map) => {
 *     const obj = new Spine(settings.x, settings.y, settings);
 *     obj.pos.z = settings.z;
 *     return obj;
 * });
 *
 * @example
 * // override the built-in "shape" factory to add custom behavior
 * registerTiledObjectFactory("shape", (settings, map) => {
 *     const obj = new Renderable(settings.x, settings.y, settings.width, settings.height);
 *     obj.pos.z = settings.z;
 *     // add custom initialization...
 *     return obj;
 * });
 */
export function registerTiledObjectFactory(type: string, factory: Function): void;
/**
 * Register a class constructor as a Tiled object factory.
 * When an object with a matching `class` or `name` is found in a Tiled map,
 * an instance of the given constructor will be created with `new Constructor(x, y, settings)`.
 * <br><br>
 * This is a convenience wrapper around {@link registerTiledObjectFactory}.
 * If the same class is registered twice with the same constructor, the call is silently ignored.
 * If a different constructor is registered for the same name, an error is thrown.
 * <br><br>
 * Note: classes registered via {@link pool.register} are also automatically registered
 * as Tiled object factories (unless {@link pool.autoRegisterTiled} is set to `false`).
 * @category Tilemap
 * @param {string} name - the Tiled class or object name to match
 * @param {Function} Constructor - class constructor with signature `(x, y, settings)`
 * @example
 * // register a custom enemy class for use in Tiled maps
 * // In Tiled: set the object class to "Enemy" and add custom properties
 * registerTiledObjectClass("Enemy", Enemy);
 *
 * @example
 * // equivalent to pool.register (which auto-registers for Tiled too)
 * pool.register("CoinEntity", CoinEntity, true);
 * // CoinEntity is now available both in the pool AND as a Tiled object factory
 */
export function registerTiledObjectClass(name: string, Constructor: Function): void;
/**
 * Queue a class for registration as a Tiled object factory.
 * Registrations are applied when initFactories() runs (on first
 * createTMXObject call), avoiding circular import issues at module load time.
 * @param {string} name - the Tiled class or name to match
 * @param {Function} Constructor - class constructor with signature (x, y, settings)
 * @ignore
 */
export function registerBuiltinTiledClass(name: string, Constructor: Function): void;
/**
 * Instantiate a TMX object based on its settings, using the registered factory
 * for its detected type.
 * @param {object} settings - TMX object settings
 * @param {TMXTileMap} map - the parent tile map
 * @returns {Renderable} the instantiated object
 * @ignore
 */
export function createTMXObject(settings: object, map: TMXTileMap): Renderable;
//# sourceMappingURL=TMXObjectFactory.d.ts.map