import type { Accessor } from '../../../accessor/base.ts';
import type { IndexCacheStore } from '../../../cache/index/store.ts';
import type { StatOverlay } from '../../../ops/types.ts';
import type { FindOptions } from '../../../resource/base.ts';
import { PathSpec, type CopyFn, type FindFn, type FileStat, type MoveFn, type ReadBytesFn, type ReadStreamFn, type ReaddirFn, type StatFn } from '../../../types.ts';
import type { ChildMounts } from '../../../ops/types.ts';
import type { DuEntries } from '../generic/du.ts';
import type { AggregateFn, CommandFnResult, CommandOpts, ProvisionFn } from '../../config.ts';
export type ReaddirOp<A extends Accessor = Accessor> = ReaddirFn<[
    accessor: A,
    path: PathSpec,
    index?: IndexCacheStore
]>;
type ReadBytesOp<A extends Accessor = Accessor> = ReadBytesFn<[
    accessor: A,
    path: PathSpec,
    index?: IndexCacheStore
]>;
type ReadStreamOp<A extends Accessor = Accessor> = ReadStreamFn<[
    accessor: A,
    path: PathSpec,
    index?: IndexCacheStore
]>;
export type StatOp<A extends Accessor = Accessor> = StatFn<[
    accessor: A,
    path: PathSpec,
    index?: IndexCacheStore
]>;
type WriteOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec, data: Uint8Array) => Promise<void>;
type ExistsOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec) => Promise<boolean>;
type PathOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec) => Promise<void>;
type RmdirOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec, index?: IndexCacheStore) => Promise<void>;
type MkdirOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec, parents?: boolean) => Promise<void>;
type RenameOp<A extends Accessor = Accessor> = MoveFn<[accessor: A, src: PathSpec, dst: PathSpec]>;
type CopyOp<A extends Accessor = Accessor> = CopyFn<[accessor: A, src: PathSpec, dst: PathSpec]>;
type FindOp<A extends Accessor = Accessor> = FindFn<[
    accessor: A,
    path: PathSpec,
    options: FindOptions
]>;
type DuSizeOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec, index?: IndexCacheStore) => Promise<number>;
type DuEntriesOp<A extends Accessor = Accessor> = (accessor: A, path: PathSpec, index?: IndexCacheStore) => Promise<DuEntries>;
export type ResolveGlobOp<A extends Accessor = Accessor> = (accessor: A, paths: readonly PathSpec[], index?: IndexCacheStore) => Promise<PathSpec[]>;
export declare function makeResolveGlob<A extends Accessor = Accessor>(readdir: ReaddirOp<A>, maxGlobMatches?: number, children?: ChildMounts): ResolveGlobOp<A>;
export interface DuOps<A extends Accessor = Accessor> {
    size: DuSizeOp<A>;
    entries: DuEntriesOp<A>;
}
export interface CommandIO<A extends Accessor = Accessor> {
    readdir: ReaddirOp<A>;
    readBytes: ReadBytesOp<A>;
    readRange?: (accessor: A, path: PathSpec, index: IndexCacheStore | undefined, offset: number, size: number | null) => Promise<Uint8Array>;
    readStream: ReadStreamOp<A>;
    stat: StatOp<A>;
    isMounted: (accessor: A) => boolean;
    local?: boolean;
    maxGlobMatches?: number;
    write?: WriteOp<A>;
    exists?: ExistsOp<A>;
    mkdir?: MkdirOp<A>;
    unlink?: PathOp<A>;
    rmdir?: RmdirOp<A>;
    rmR?: PathOp<A>;
    rename?: RenameOp<A>;
    copy?: CopyOp<A>;
    dirCopy?: CopyOp<A>;
    create?: PathOp<A>;
    truncate?: (accessor: A, path: PathSpec, length: number) => Promise<void>;
    find?: FindOp<A>;
    du?: DuOps<A>;
    maxDuEntries?: number;
    append?: (accessor: A, path: PathSpec, data: Uint8Array) => Promise<void>;
    setAttrs?: (...args: any[]) => unknown;
    globChildren?: ChildMounts;
}
export declare function resolveGlobOf<A extends Accessor = Accessor>(ops: CommandIO<A>): ResolveGlobOp<A>;
/** Refuse a relocation that would surface a hidden path.
 *
 * A rename or a native directory copy re-anchors everything below its
 * source, and a hide's coverage does not move with the content, so
 * hidden bytes would land at paths the session can see. EACCES on the
 * source, which mv and cp render in GNU's permission-denied voice.
 * Only a directory has anything below it to re-anchor, so callers
 * check this for a source they know is a directory and skip it for a
 * file. */
export declare function refuseReveal(src: PathSpec, dst: PathSpec): void;
/**
 * Return `ops` whose slots refuse hidden paths like missing ones.
 *
 * The commands factory hands this copy to every generic command, the
 * same shape as `withReadCache`, so hidden-path enforcement lands once
 * for the whole command tier (resolveGlobOf derives from the wrapped
 * readdir). The backends' own IO constants stay raw: the ops tables
 * built from them serve the dispatcher, which enforces hiding itself
 * at the door. The guards read the current session at call time, so
 * one wrapped copy is shared across sessions.
 */
export declare function withHiddenGuard<A extends Accessor = Accessor>(ops: CommandIO<A>): CommandIO<A>;
/**
 * Return `ops` whose content and mutation slots ask the admitted
 * command's gate before touching a path.
 *
 * The rule arms' counterpart of `withHiddenGuard`, wrapped inside it so
 * a hidden path still answers ENOENT before any rule can name it. The
 * gate judged the line's operands; this is how a walk (`grep -r`, `find`,
 * `du`, `cp -r`, `tar`) is held to the same rules on the entries it
 * reaches below them. `stat` and `exists` stay unguarded, because deny
 * means present and refused, not absent: a listing shows a refused
 * entry's name and size, and the read of it is what fails, as GNU reports
 * an unreadable file. `readdir` asks about the directory being listed,
 * never filters its names. A backend's native `find`/`du` are not
 * wrapped: the builders route to the readdir walk while a path rule
 * scopes the command (`pathRulesActive`), so every entry passes through
 * here.
 */
export declare function withRuleGuard<A extends Accessor = Accessor>(ops: CommandIO<A>): CommandIO<A>;
/**
 * Return `ops` whose mutation slots hold each written path to its
 * region's effective mode.
 *
 * The per-path half of the mount's write gate, innermost of the three
 * guards: hides answer ENOENT first, rules refuse next, and only a path
 * both leave standing is judged for its mode, the same order the op
 * door applies. Reads are never wrapped, because `READ` allows them
 * everywhere the other guards do; a copy's source is a read too, so
 * only its destination answers, while a rename mutates both endpoints.
 */
export declare function withModeGuard<A extends Accessor = Accessor>(ops: CommandIO<A>): CommandIO<A>;
/**
 * Return `ops` under the whole path axis: hides answer ENOENT first,
 * rules refuse next, the mode speaks last.
 *
 * The one spelling of the guard chain, used by the commands factory
 * for every generic command and by a bespoke command family that
 * consumes a `CommandIO` directly (the object-store overrides), so an
 * override enforces the session's path axis exactly like the generic
 * it replaces.
 */
export declare function withPathGuards<A extends Accessor = Accessor>(ops: CommandIO<A>): CommandIO<A>;
/**
 * Return `ops` whose content and mutation slots admit each PathSpec
 * through the workspace's coded preOps hooks.
 *
 * The coded-policy arm of the guard chain, applied outside the cache
 * wraps so admission fires before a warm serve, the dispatcher's own
 * order. The surface is the rule guard's plus readdir: content reads
 * (readBytes, readStream, readRange), every mutation slot, and the
 * directory a readdir lists. stat/exists and the native find/du slots
 * stay unguarded as presence facts, the mode-000 shape the rule guard
 * already states, so a denied entry still lists and stats while the
 * read of it is what fails. Inert unless a dispatched command bound
 * policies overriding preOps (`opPolicyScope`, with the mount prefix
 * and session identity captured at wrap time so a lazily drained
 * reader still answers as the command that bound it, see
 * `livePolicyScope`; `prefix` arrives from the wrap site because the
 * fallback mount-gate storage resolves by path, which a drained
 * reader no longer has a live gate for).
 */
export declare function withPolicyGuard<A extends Accessor = Accessor>(ops: CommandIO<A>, prefix?: string): CommandIO<A>;
/**
 * Guard one bare backend write the way the adapter guards a slot.
 *
 * For a bespoke command wired from loose functions rather than a
 * `CommandIO` (the google `rm` family binds an index-threaded unlink):
 * the same chain in the same order, judging the written path. A hidden
 * path answers ENOENT, the flavor of the flat mutation slots. The
 * policy arm rides outermost, as it does on the slot chain, and reads
 * the live context (this wrap happens at registration, its handlers
 * are eager).
 */
export declare function withWriteGuards<A extends Accessor, R>(fn: (accessor: A, path: PathSpec, index?: IndexCacheStore) => Promise<R> | R): (accessor: A, path: PathSpec, index?: IndexCacheStore) => Promise<R>;
/**
 * A `readRange` slot built from a backend read that already takes a byte
 * window as its options argument.
 *
 * Without the slot the ops factory reads the whole object and slices, so
 * `head -c 100` on a 2 GiB S3 key downloads 2 GiB. Python has pushed the
 * window down on every one of these backends since the slot existed by
 * pointing `read_range` at its own `read_bytes`; this is the same move,
 * spelled for a read whose window arrives in an options object.
 *
 * Args:
 *   read: the backend's whole-file read, whose fourth argument is an
 *     `{offset?, size?}` window.
 */
export declare function rangeOf<A extends Accessor = Accessor>(read: (accessor: A, path: PathSpec, index: IndexCacheStore | undefined, options: {
    offset?: number;
    size?: number;
}) => Promise<Uint8Array>): NonNullable<CommandIO<A>['readRange']>;
export declare function dirAwareStat<A extends Accessor>(ops: CommandIO<A>, accessor: A, opts: CommandOpts): (p: PathSpec) => Promise<FileStat>;
export declare function overlaidStat(stat: (p: PathSpec) => Promise<FileStat>, overlay: StatOverlay | undefined): (p: PathSpec) => Promise<FileStat>;
export declare function requireOp<T>(op: T | undefined, name: string): T;
/**
 * Return `ops` whose reads refuse a directory with GNU's EISDIR.
 *
 * The read family's counterpart of `withHiddenGuard` and
 * `withSlashGuard`: reading a directory is never a legitimate call, so
 * the refusal belongs to the slot rather than to each builder's wiring.
 * It used to belong to the wiring, and 23 of the read builders passed the
 * raw `ops.readStream` instead, so a directory on a keyed backend
 * reported ENOENT.
 *
 * Refined after the failure, never before it, so a read that succeeds
 * costs exactly what it did. The refusal is built from the operand's own
 * PathSpec, so it carries the virtual path: a raw disk error names the
 * host path, which is the mount's own business and must not reach a
 * user-facing line.
 *
 * Mirrors the Python `with_dir_guard`.
 */
export declare function withDirGuard<A extends Accessor = Accessor>(ops: CommandIO<A>): CommandIO<A>;
export declare function dirAwareStream<A extends Accessor>(ops: CommandIO<A>, accessor: A, opts: CommandOpts): (p: PathSpec) => AsyncIterable<Uint8Array>;
export type BuilderFn<A extends Accessor = Accessor> = (ops: CommandIO<A>, accessor: A, paths: PathSpec[], texts: string[], opts: CommandOpts) => Promise<CommandFnResult> | CommandFnResult;
export type Operation = 'write' | 'exists' | 'mkdir' | 'unlink' | 'rmdir' | 'rename' | 'copy' | 'truncate';
export declare function supports<A extends Accessor = Accessor>(ops: CommandIO<A>, requirements: readonly Operation[]): boolean;
export interface Builder<A extends Accessor = Accessor> {
    name: string;
    fn: BuilderFn<A>;
    provision?: (stat: StatOp<A>) => ProvisionFn<A>;
    write?: boolean;
    aggregate?: AggregateFn;
    read?: boolean;
    /**
     * Backend ops the command cannot run without. A backend missing any of
     * them does not get the command registered at all, rather than getting a
     * command that throws on every invocation. `write: true` is not enough on
     * its own: rmdir needs `rmdir`, truncate needs `truncate`, and a backend
     * can have `write` without either.
     */
    requirements?: readonly Operation[];
}
export {};
//# sourceMappingURL=adapter.d.ts.map