import { type KitBlueprint, type KitOwnerIdKind } from './core.js';
/** Options for {@link combatBlueprint}. */
export interface CombatBlueprintOptions {
    /** Prefix for the type/function names. Defaults to none. */
    typePrefix?: string;
    /**
     * Turn-based mode: adds `is_current_turn` to the attack/apply_effect
     * policies, so only the player whose session turn it is may act. Defaults
     * to false.
     */
    turnBased?: boolean;
    /**
     * Host-synced mode for **fast** combat: adds a `sync_combatant` function
     * gated `is_host` so the elected host client can run smooth per-frame
     * combat on the replication plane and periodically write the durable hp
     * back (the Blocks-with-Friends `mob_update` precedent, with the policy
     * actually enforced). Defaults to false.
     */
    hostSynced?: boolean;
    /**
     * Interval of the status-effect tick automation, in ms (dispatcher floor
     * is seconds). Defaults to 5000.
     */
    effectTickIntervalMs?: number;
    /**
     * Who may instantiate combatants: `'member'` (player characters; the
     * default) or `'admin'` (studio-spawned mobs).
     */
    combatantInstantiableBy?: 'member' | 'admin';
    /**
     * When set, adds a `revive` function gated on this team/group permission
     * (e.g. a healer role), usable on any downed combatant.
     */
    reviveGroup?: {
        groupId: string;
        permission?: string;
    };
    /** Owner-mirror typing (see the kit convention). Defaults to `'int'`. */
    ownerIdKind?: KitOwnerIdKind;
}
/** Names derived by {@link combatBlueprint} for a given prefix. */
export interface CombatNames {
    combatantType: string;
    effectType: string;
    attackFn: string;
    applyEffectFn: string;
    effectTickFn: string;
    respawnFn: string;
    reviveFn: string;
    syncFn: string;
    effectTickAutomation: string;
}
/** Compute the type/function names a combat blueprint (and its runtime helper) uses. */
export declare function combatNames(typePrefix?: string): CombatNames;
/**
 * Blueprint for **server-authoritative combat** (the turn-based / MMO-durable
 * tier): `Combatant` containers (hp / attack / defense / alive), an `attack`
 * function whose damage formula and death flip run entirely server-side,
 * status effects as `StatusEffect` containers ticked by an interval
 * automation (damage-over-time with no client online), and respawn/revive.
 *
 * The effect tick uses the selector **join** pattern: each combatant carries
 * a unique `combat_key`, effects record a `target_key`, and the automation's
 * selector binds the matching combatant as a `$target` ref param
 * (`where combat_key == self.target_key`) — automations cannot follow
 * property refs directly.
 *
 * For fast-twitch combat keep the per-frame simulation on the replication
 * plane under host authority and set `hostSynced: true` to get the
 * `is_host`-gated durable sync function.
 *
 * Runtime counterpart: `client.kit(appId).combat`.
 */
export declare function combatBlueprint(options?: CombatBlueprintOptions): KitBlueprint;
//# sourceMappingURL=combat.d.ts.map