/**
 * Gematria calculation utilities for Hebrew, Greek, and English text.
 */
import type { GematriaValues } from '../models/types.js';
import { computeHebrew } from './hebrew.js';
import { computeGreek } from './greek.js';
import { computeEnglish } from './english.js';
export { computeHebrew, isHebrew, extractHebrewLetters, computeStandard as computeHebrewStandard } from './hebrew.js';
export { computeGreek, isGreek, removeDiacritics, extractGreekLetters, computeStandard as computeGreekStandard } from './greek.js';
export { computeEnglish, isEnglish, extractEnglishLetters } from './english.js';
export { createGematriaProxy, createVerseGematriaProxy, createVerseGematriaWithColophonsProxy, createGetGematriaMethod, normalizeLanguage } from './proxy.js';
export type { VerseGematriaOptions } from './proxy.js';
/**
 * Supported languages for gematria calculations.
 */
export type GematriaLanguage = 'hebrew' | 'greek' | 'english' | 'auto';
/**
 * Gematria method definition with canonical and simple names.
 */
export interface GematriaMethod {
    /** Canonical slug (e.g., 'mispar_hechrachi') */
    slug: string;
    /** Display name (e.g., 'Mispar Hechrachi') */
    name: string;
    /** Optional simple alias (e.g., 'standard') */
    simpleName?: string;
    /** Description of the method */
    description?: string;
    /** Language this method applies to */
    language: GematriaLanguage;
    /** Compute function */
    compute: (text: string) => number;
}
/**
 * Register a gematria method.
 */
export declare function registerMethod(method: GematriaMethod): void;
/**
 * Get a method by slug or simple name.
 */
export declare function getMethod(slugOrName: string, language?: GematriaLanguage): GematriaMethod | undefined;
/**
 * List all registered methods, optionally filtered by language.
 */
export declare function listMethods(language?: GematriaLanguage): GematriaMethod[];
/**
 * List method slugs for a language.
 */
export declare function listMethodSlugs(language: GematriaLanguage): string[];
/**
 * List simple names for a language.
 */
export declare function listSimpleNames(language: GematriaLanguage): string[];
/**
 * Options for gematria computation.
 */
export interface GematriaOptions {
    /** Language to use for calculation. Default: 'auto' */
    language?: GematriaLanguage;
    /** Specific method to use. Default: all methods */
    method?: string;
}
/**
 * Detect the language of the given text.
 */
export declare function detectLanguage(text: string): GematriaLanguage;
/**
 * Compute gematria values for the given text.
 *
 * @param text - The text to compute gematria for
 * @param options - Computation options
 * @returns Gematria values for different methods
 * @throws GematriaError if text contains no valid characters
 */
export declare function compute(text: string, options?: GematriaOptions): GematriaValues;
/**
 * Compute a single gematria value using a specific method.
 *
 * @param text - The text to compute gematria for
 * @param method - The method slug or simple name (e.g., 'mispar_hechrachi', 'standard')
 * @param language - The language to use. Default: 'auto'
 * @returns The gematria value
 */
export declare function computeValue(text: string, method?: string, language?: GematriaLanguage): number;
export { registerMethod as registerSystem };
export type GematriaSystem = GematriaMethod;
export declare const getSystem: typeof getMethod;
export declare const listSystems: () => string[];
declare const _default: {
    compute: typeof compute;
    computeValue: typeof computeValue;
    computeHebrew: typeof computeHebrew;
    computeGreek: typeof computeGreek;
    computeEnglish: typeof computeEnglish;
    detectLanguage: typeof detectLanguage;
    listMethods: typeof listMethods;
    listMethodSlugs: typeof listMethodSlugs;
    listSimpleNames: typeof listSimpleNames;
    getMethod: typeof getMethod;
    registerMethod: typeof registerMethod;
};
export default _default;
//# sourceMappingURL=index.d.ts.map