/**
 * Define a remote domain. Views/functions are first-class domain members; their
 * serving URL is stamped later by spec producers and is also the worker issuer.
 */
import type { FunctionBinding } from '@astrale-os/kernel-api/routed';
import type { BoundMethod, CompiledDomain, FunctionSchema, ViewSchema } from '@astrale-os/kernel-core/domain';
import type { Core, Schema } from '@astrale-os/kernel-dsl';
import type { DomainManifest } from '../config/define-domain.js';
import type { AnyRemoteFunctionDef, ViewDef } from '../define/index.js';
import type { SchemaMethodsImpl } from '../method/class.js';
import type { AnyRemoteHandler } from '../method/single.js';
export type RemoteDomainConfig<S extends Schema, TDeps> = {
    schema: S;
    methods: SchemaMethodsImpl<S, TDeps>;
    core?: Core<S>;
    views?: Record<string, ViewDef<TDeps>>;
    viewsFolder?: string;
    remoteFunctions?: Record<string, AnyRemoteFunctionDef>;
    functionsFolder?: string;
    /** Presentation metadata for `/meta` (logo / entry view). Carried verbatim. */
    manifest?: DomainManifest;
    /** Physical tree path for the Domain node (absolute, e.g. `/domains/acme`); default `/domains/<origin>`. */
    path?: string;
};
/** Effective bindings + folder layout + member schemas for auxiliary routes, resolved against `url`. */
export type AuxiliaryMetadata = {
    url: string;
    viewsFolder: string;
    functionsFolder: string;
    viewBindings: Record<string, FunctionBinding>;
    remoteFunctionBindings: Record<string, FunctionBinding>;
    /** Function members' impl/binding half (`function.<slug>`) for `serialize`. */
    functionSchemas: FunctionSchema[];
    /** View members' impl/binding half (`view.<slug>`) for `serialize`. */
    viewSchemas: ViewSchema[];
};
export type RemoteDomain<S extends Schema = Schema> = {
    /** Define-time compile has structure only; bindings are stamped at materialization. */
    compiled: CompiledDomain<S>;
    methods: BoundMethod<AnyRemoteHandler>[];
    views?: Record<string, ViewDef<any>>;
    remoteFunctions?: Record<string, AnyRemoteFunctionDef>;
    /** Presentation metadata for `/meta` (logo / entry view); `createRemoteServer` stamps it. */
    manifest?: DomainManifest;
    /** The original config, so `materializeRemoteDomain` re-materializes from source. */
    config: MaterializeInputs;
    /**
     * Physical tree path for the Domain node (absolute string, e.g. `/domains/acme`).
     * Read by `buildInstallGraph` and passed to `serialize` as `treeMount`; unset =>
     * `/domains/<origin>` (applied in build-spec). Addressing is unaffected.
     */
    path?: string;
};
/** The defineRemoteDomain inputs `materializeRemoteDomain` needs to re-materialize. */
type MaterializeInputs = {
    userCore?: Core;
    viewsFolder: string;
    functionsFolder: string;
};
export declare function defineRemoteDomain<TDeps>(): <S extends Schema>(config: RemoteDomainConfig<S, TDeps>) => RemoteDomain<S>;
/** Materialize aux member bindings against the real serving URL. Pure and repeatable. */
export declare function materializeRemoteDomain<S extends Schema>(domain: RemoteDomain<S>, url: string): {
    compiled: CompiledDomain<S>;
    auxiliary: AuxiliaryMetadata | undefined;
};
export {};
//# sourceMappingURL=define.d.ts.map