/**
 * Modules (#1062, DESIGN §12.7): a template with `role: 'module'` is a box
 * of frames, groups and decoration that a page stacks in its modules group
 * (`groups: [{ name, modules: true }]`), one per `:::module{template="…"}`
 * block of the page fence, in Markdown order.
 *
 * {@link expandModules} turns a page template and the modules its page
 * lays into one template with every module's frames, groups and decoration
 * as the page's own, scoped by the instance name: `<name>.<frame>` (the
 * fence's `name`, else `<template>[n]`). Anchors, `next` and `continueIn:
 * '#x'` inside a module are rewritten to the instance; a module frame
 * anchored to `'container'` (or to nothing) reads its module's box, which
 * the layout gives it (as wide as the group, as tall as its frames); a
 * decoration element anchored to `'container'` is anchored to `#<name>`,
 * the module's box. The modules group lists every module frame, in module
 * order, and its `items` say which belong to which module (and, #1088,
 * which modules group inside it lays the module); the module's own groups
 * follow the page's. Everything after (the stories, the
 * ladder, continuation, ids, the source map) sees plain frames.
 *
 * Pure. Run by `resolvePageTemplate` when it is given the page's modules.
 */
import type { ComposedPageFence } from '../parse/types.js';
import type { ComposedModuleUse, ResolvedFrameGroup, ResolvedModule, ResolvedPageTemplate } from './types.js';
/** The name of a module's frame, group or element `local` in instance
 *  `instance`. */
export declare function moduleScoped(instance: string, local: string): string;
/**
 * `page` with the modules `uses` laid in its modules group (see the
 * module comment). `moduleOf` resolves a module template by id. A use
 * whose template is unknown or no module, or whose name an earlier use
 * took, is left out (the slot checks report it); a page with no modules
 * group, or no use left, comes back as it is.
 */
export declare function expandModules(page: ResolvedPageTemplate, uses: readonly ComposedModuleUse[], moduleOf: (id: string) => ResolvedPageTemplate | undefined): ResolvedPageTemplate;
/** The modules group `g` lies in at the end of its `within` chain (#1088,
 *  #1095): the one inside no other, `g` itself when it names none.
 *  Undefined when the chain names a group that is no modules group of
 *  `groups`, or comes back on itself. */
export declare function modulesGroupRoot(groups: readonly Pick<ResolvedFrameGroup, 'name' | 'modules' | 'within'>[], g: Pick<ResolvedFrameGroup, 'name' | 'modules' | 'within'>): string | undefined;
/** The modules groups `nested` lies in (#1095), innermost first: `nested`
 *  itself, then the group it lies `within`, and so on, the page's modules
 *  group (the one inside no other) left out. */
export declare function nestedChain(groups: readonly Pick<ResolvedFrameGroup, 'name' | 'within'>[], nested: string | undefined): string[];
/** The module a frame of an expanded template belongs to (#1062), with its
 *  modules group and its place among the group's modules (1-based). */
export declare function moduleOfFrame(template: Pick<ResolvedPageTemplate, 'groups' | 'modules'>, name: string): {
    module: ResolvedModule;
    group: ResolvedFrameGroup;
    item: number;
    frames: string[];
} | undefined;
/** The modules a page of `template` lays, as uses (`VDTComposedPage.modules`). */
export declare function moduleUses(template: Pick<ResolvedPageTemplate, 'modules'>): ComposedModuleUse[] | undefined;
/** `list` as the uses `resolvePageTemplate` takes (#1062): each name once,
 *  in order, a nested module left out. Undefined when none is left. */
export declare function moduleUsesOf(list: readonly {
    name: string;
    template: string;
    nested?: true;
}[] | undefined): ComposedModuleUse[] | undefined;
/** The attributes the `:::module` fence of instance `name` writes besides
 *  `template` and `name` (#1189), with each value's source range moved by
 *  `offset` (the chapter's body offset): what `{attr.x}` in the module's
 *  decoration reads before the page fence's (`VDTComposedPage.modules[]`).
 *  Empty when it writes none, so a page whose modules write no attribute
 *  records the same modules as before. */
export declare function moduleFenceAttrs(fence: Pick<ComposedPageFence, 'modules'>, name: string, offset: number): {
    attrs?: Record<string, string>;
    attrSources?: Record<string, {
        sourceStart: number;
        sourceEnd: number;
    }>;
};
//# sourceMappingURL=modules.d.ts.map