/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
import { ServerSubscriptionConfig } from "#node/server/ServerSubscription.js";
import { DeepPartial, Duration } from "@matter/general";
import { NetworkProfiles, PeerTimingParameters } from "@matter/protocol";
import { DiscoveryCapabilitiesBitmap, TypeFromPartialBitSchema } from "@matter/types";
import { NetworkBehavior } from "./NetworkBehavior.js";
import type { ServerNetworkRuntime } from "./ServerNetworkRuntime.js";
/**
 * Server implementation of {@link NetworkBehavior}.
 *
 * This behavior mostly deals with configuration and events.  {@link ServerNetworkRuntime} provides the actual network
 * implementation.
 */
export declare class NetworkServer extends NetworkBehavior {
    #private;
    readonly state: NetworkServer.State;
    internal: NetworkServer.Internal;
    initialize(): import("@matter/general").MaybePromise;
}
export declare namespace NetworkServer {
    export class Internal extends NetworkBehavior.Internal {
        runtime: ServerNetworkRuntime;
    }
    export class KickRestartCooldownConfig implements Partial<PeerTimingParameters["kickRestartCooldown"]> {
        addressChange?: Duration;
        connect?: Duration;
    }
    export class AddressChangeProbeCooldownConfig implements Partial<PeerTimingParameters["addressChangeProbeCooldown"]> {
        minimum?: Duration;
        maximum?: Duration;
    }
    export class TimingConfig implements DeepPartial<PeerTimingParameters> {
        defaultConnectionTimeout?: Duration;
        maxDelayBetweenInitialContactRetries?: Duration;
        delayBeforeNextAddress?: Duration;
        delayAfterNetworkError?: Duration;
        delayAfterPeerError?: Duration;
        delayAfterUnhandledError?: Duration;
        kickThrottleInterval?: Duration;
        kickMinRetransmissions?: number;
        kickMinRestartSaving?: Duration;
        kickRestartCooldown?: KickRestartCooldownConfig;
        addressChangeStabilizationDelay?: Duration;
        addressChangeProbeCooldown?: AddressChangeProbeCooldownConfig;
    }
    export class ConcreteLimitsConfig implements Partial<NetworkProfiles.ConcreteLimits> {
        exchanges?: number;
        delay?: Duration;
        timeout?: Duration;
        additionalMrpDelay?: Duration;
    }
    export class LimitsConfig extends ConcreteLimitsConfig {
        connect?: ConcreteLimitsConfig;
        probeAddress?: ConcreteLimitsConfig;
    }
    export class ProfilesConfig implements NetworkProfiles.PartialOptions {
        fast?: LimitsConfig;
        wifi?: LimitsConfig;
        thread?: LimitsConfig;
        conservative?: LimitsConfig;
        unknown?: LimitsConfig;
        unlimited?: LimitsConfig;
        icdLit?: LimitsConfig;
    }
    type Mismatched<A, B> = Exclude<keyof A, keyof B> | Exclude<keyof B, keyof A>;
    type SameFields<_Mismatched extends never> = unknown;
    /**
     * The config classes above restate their source's fields because {@link field} needs real property declarations,
     * and `implements Partial<Source>` catches neither a field they fail to declare nor one the source has dropped.
     * This does: either divergence breaks the build here, naming the offending field.
     */
    export type ConfigMatchesItsSource = [
        SameFields<Mismatched<PeerTimingParameters, TimingConfig>>,
        SameFields<Mismatched<PeerTimingParameters["kickRestartCooldown"], KickRestartCooldownConfig>>,
        SameFields<Mismatched<PeerTimingParameters["addressChangeProbeCooldown"], AddressChangeProbeCooldownConfig>>,
        SameFields<Mismatched<NetworkProfiles.ConcreteLimits, ConcreteLimitsConfig>>,
        SameFields<Mismatched<NetworkProfiles.Limits, LimitsConfig>>,
        SameFields<Mismatched<NetworkProfiles.Templates, ProfilesConfig>>
    ];
    export class State extends NetworkBehavior.State {
        listeningAddressIpv4?: string;
        listeningAddressIpv6?: string;
        ipv4: boolean;
        ble?: boolean;
        discoveryCapabilities: TypeFromPartialBitSchema<typeof DiscoveryCapabilitiesBitmap>;
        subscriptionOptions?: ServerSubscriptionConfig;
        /**
         * Enable TCP transport. `true` enables both incoming (server) and outgoing (client).
         * Fine-grained control via `{ incoming?: boolean; outgoing?: boolean }`.
         * Disabled by default.
         */
        tcp?: boolean | {
            incoming?: boolean;
            outgoing?: boolean;
        };
        /**
         * Preferred transport for outgoing connections. Defaults to UDP when not set.
         */
        transportPreference?: "tcp" | "udp";
        /**
         * Network profile describing our own (local) network — the sender-side MRP additive-delay
         * axis.  Defaults to "fast"; set to "thread" on a Thread device.
         */
        ownNetworkProfileId: keyof NetworkProfiles.Templates;
        timing?: TimingConfig;
        profiles?: ProfilesConfig;
        /**
         * Interval at which dirty client cache data is flushed to storage.  Set to `undefined` to disable buffering
         * and persist every change immediately.
         */
        clientCacheFlushInterval?: Duration;
    }
    /**
     * Resolve the tcp shorthand to explicit incoming/outgoing booleans.
     */
    export function resolveTcpConfig(tcp?: boolean | {
        incoming?: boolean;
        outgoing?: boolean;
    }): {
        incoming: boolean;
        outgoing: boolean;
    };
    export {};
}
//# sourceMappingURL=NetworkServer.d.ts.map