type Awaitable<Value> = Value | PromiseLike<Value>;
type ScopeKind = "terminal" | "storeWriter" | "state";
export type CanonicalMutationResource<Value = unknown> = Readonly<{
    key: string;
    value: Value;
}>;
type ScopeResources = Readonly<Record<ScopeKind, CanonicalMutationResource>>;
export type CanonicalMutationResources = Readonly<Pick<ScopeResources, "terminal" | "storeWriter"> & Partial<ScopeResources>>;
export type CanonicalStateMutationResources = Readonly<ScopeResources>;
declare const mutationScopeBrand: unique symbol;
type MutationScope<Kind extends ScopeKind> = Readonly<{
    [mutationScopeBrand]: Kind;
}>;
export type CanonicalMutationScopes = Readonly<{
    terminal: MutationScope<"terminal">;
    storeWriter: MutationScope<"storeWriter">;
    state?: MutationScope<"state">;
}>;
export type CanonicalStateMutationScopes = CanonicalMutationScopes & Readonly<{
    state: MutationScope<"state">;
}>;
export type CanonicalMutationLockPorts = Readonly<{
    resources: CanonicalMutationResources;
    acquireTerminal: () => Awaitable<() => void>;
    afterTerminalAcquired?: () => Awaitable<void>;
    withStoreWriter: <Result>(operation: () => Promise<Result>) => Promise<Result>;
    acquireState?: () => Awaitable<() => void>;
}>;
export declare function canonicalMutationResource<Value>(key: string, value: Value): Readonly<{
    key: string;
    value: Value;
}>;
type ScopesFor<Kinds extends readonly ScopeKind[]> = Pick<CanonicalStateMutationScopes, Kinds[number]>;
export declare function capabilityGatedRepositoryOperation<const Required extends readonly ScopeKind[], Bound extends Required[number], Resource, Args extends unknown[], Result>(required: Required, bound: Bound, operation: (resource: Resource, ...args: Args) => Result): (scopes: ScopesFor<Required>, resources: Pick<ScopeResources, Required[number]>, ...args: Args) => Result;
export declare function capabilityGatedRepositoryPairOperation<const Required extends readonly ScopeKind[], First extends Required[number], Second extends Required[number], FirstResource, SecondResource, Args extends unknown[], Result>(required: Required, bound: readonly [First, Second], operation: (first: FirstResource, second: SecondResource, ...args: Args) => Result): (scopes: ScopesFor<Required>, resources: Pick<ScopeResources, Required[number]>, ...args: Args) => Result;
type ScopesForPorts<Ports> = Ports extends {
    acquireState: () => unknown;
} ? CanonicalStateMutationScopes : CanonicalMutationScopes;
type ResourcesForPorts<Ports> = Ports extends {
    acquireState: () => unknown;
} ? ScopeResources : CanonicalMutationResources;
/** Acquire terminal -> writer -> optional state and release in reverse. */
export declare function withCanonicalMutationLocks<Result, Ports extends CanonicalMutationLockPorts>(ports: Ports, operation: (scopes: ScopesForPorts<Ports>, resources: ResourcesForPorts<Ports>) => Promise<Result>): Promise<Result>;
/** Add one state scope to the currently active terminal + writer transaction. */
export declare function withCanonicalStateMutationLock<Result, StateResource>(scopes: CanonicalMutationScopes, resources: CanonicalMutationResources, state: Readonly<{
    resource: CanonicalMutationResource<StateResource>;
    acquire: () => Awaitable<() => void>;
}>, operation: (scopes: CanonicalStateMutationScopes, resources: CanonicalStateMutationResources) => Promise<Result>): Promise<Result>;
export {};