/**
 * Class-level method aggregation.
 *
 * Where `RemoteHandler` describes one method, the types here describe a
 * whole class's worth of methods. `ClassMethodsImpl<S, K, TDeps>` enforces
 * that every implementable method on class `K` is provided. The interface
 * variant handles abstract definitions; the schema variant indexes by class
 * name.
 *
 * `remoteClassMethods` is the identity helper an author calls when supplying
 * a class's full method record — it gives full inference for the class
 * methods at once, complementing `remoteMethod` (one method at a time).
 */
import type { DefForInterface, InterfaceMethodDefs, InterfaceMethodKeys, MethodClassKeys, NonSealedMethodKeys, OwnMethodKeys, ResolveParams, ResolveReturn, SealedKeys } from '@astrale-os/kernel-core/domain';
import type { ImplementableOwnKeys, Schema } from '@astrale-os/kernel-dsl';
import type { TypedSelf } from '../dispatch/self.js';
import type { DomainKernel } from './context.js';
import type { MethodImpl, RemoteHandler } from './single.js';
/** Per-class method implementations for a remote domain. */
export type ClassMethodsImpl<S extends Schema, K extends MethodClassKeys<S> & string, TDeps = unknown> = {
    [M in OwnMethodKeys<S, K>]: MethodImpl<S, K, M, TDeps>;
} & {
    [M in NonSealedMethodKeys<S, K>]: MethodImpl<S, K, M, TDeps>;
} & {
    [M in SealedKeys<S, K>]?: never;
};
/** Resolve interface method handler directly (InterfaceMethodKeys ≠ MethodKeys). */
type InterfaceMethodHandler<S extends Schema, K extends string, M extends string, TDeps> = M extends keyof InterfaceMethodDefs<S, K> ? InterfaceMethodDefs<S, K>[M] extends {
    readonly config: infer MC;
} ? MC extends {
    readonly static: true;
} ? RemoteHandler<ResolveParams<MC>, ResolveReturn<MC>, undefined, TDeps, 'required', DomainKernel<S>> : RemoteHandler<ResolveParams<MC>, ResolveReturn<MC>, TypedSelf<DefForInterface<S, K>, S>, TDeps, 'required', DomainKernel<S>> : never : never;
/** Per-interface method implementations. */
export type InterfaceMethodsImpl<S extends Schema, K extends InterfaceMethodKeys<S> & string, TDeps = unknown> = {
    [M in ImplementableOwnKeys<DefForInterface<S, K>> & string]: InterfaceMethodHandler<S, K, M, TDeps>;
};
/**
 * Namespace-keyed full schema methods map, parameterized by deps.
 * Handlers for classes and interfaces live under distinct `class` / `interface`
 * slots, preventing name collisions between a class and an interface with the
 * same name.
 *
 * `interface` is optional — schemas without non-abstract interface methods
 * (or with no interfaces at all) do not need to provide it.
 */
export type SchemaMethodsImpl<S extends Schema, TDeps = unknown> = {
    class: {
        [K in MethodClassKeys<S> & string]: ClassMethodsImpl<S, K, TDeps>;
    };
    interface?: {
        [K in InterfaceMethodKeys<S> & string]: InterfaceMethodsImpl<S, K, TDeps>;
    };
};
type RejectSealedKeys<S extends Schema, K extends string, I> = keyof I & SealedKeys<S, K> extends never ? I : `Error: sealed methods must not be implemented by class '${K}': ${keyof I & SealedKeys<S, K> & string}`;
/** Identity helper for authoring one class's remote methods with full schema typing. */
export declare function remoteClassMethods<TDeps>(): <S extends Schema, K extends MethodClassKeys<S> & string, I extends ClassMethodsImpl<S, K, TDeps>>(schema: S, className: K, impl: I & RejectSealedKeys<S, K, I>) => I;
export declare function remoteClassMethods<S extends Schema, K extends MethodClassKeys<S> & string, I extends ClassMethodsImpl<S, K>>(schema: S, className: K, impl: I & RejectSealedKeys<S, K, I>): I;
/**
 * Identity helper for authoring one interface's remote methods with full
 * schema typing — the interface-hosted counterpart of `remoteClassMethods`.
 *
 * Methods declared on an interface (e.g. a static `createNote` on `NoteOps`)
 * live under the `interface:` slot of `SchemaMethodsImpl`. Without this helper
 * an author has to fall back to `any` (there is no other way to name the
 * per-method handler type — `InterfaceMethodHandler` is internal). Returns the
 * per-interface impl object the `interface: { <Name>: … }` slot expects.
 */
export declare function remoteInterfaceMethods<TDeps>(): <S extends Schema, K extends InterfaceMethodKeys<S> & string, I extends InterfaceMethodsImpl<S, K, TDeps>>(schema: S, interfaceName: K, impl: I) => I;
export declare function remoteInterfaceMethods<S extends Schema, K extends InterfaceMethodKeys<S> & string, I extends InterfaceMethodsImpl<S, K>>(schema: S, interfaceName: K, impl: I): I;
export {};
//# sourceMappingURL=class.d.ts.map