import { SystemStatusCodes } from "../../../jacdac-spec/dist/specconstants";
import { JDServerServiceProvider } from "./serverserviceprovider";
import { JDEventSource } from "../eventsource";
import { Packet } from "../packet";
import { JDRegisterServer } from "./registerserver";
import { PackedValues } from "../pack";
import { JDService } from "../service";
/**
 * Server instiation options
 * @category Servers
 */
export interface JDServerOptions {
    /**
     * Service instance name
     */
    instanceName?: string;
    /**
     * This server instance is a twin of a physical device and should not emit any packet
     */
    twin?: JDService;
    /**
     * Initial value for the ``value`` register
     */
    valueValues?: PackedValues;
    /**
     * Initial value for the ``intensity`` register
     */
    intensityValues?: PackedValues;
    /**
     * A callback to transform the received intensity value data
     */
    intensityProcessor?: (values: PackedValues) => PackedValues;
    /**
     * Emit active/inactive events based on the intensity register
     */
    isActive?: (intensity: PackedValues) => boolean;
    /**
     * Initial value for the ``variant`` register
     */
    variant?: number;
    /**
     * Optional client variant register
     */
    clientVariant?: string;
    /**
     * A map of custom register initial values
     */
    registerValues?: {
        code: number;
        values: PackedValues;
    }[];
}
/**
 * Base class for service server implementations
 * @category Servers
 */
export declare class JDServiceServer extends JDEventSource {
    readonly serviceClass: number;
    serviceIndex: number;
    private _device;
    readonly specification: jdspec.ServiceSpec;
    private readonly _registers;
    private readonly commands;
    readonly statusCode: JDRegisterServer<[SystemStatusCodes, number]>;
    readonly instanceName: JDRegisterServer<[string]>;
    private _twin;
    private _twinCleanup;
    private _locked;
    constructor(serviceClass: number, options?: JDServerOptions);
    get device(): JDServerServiceProvider;
    set device(value: JDServerServiceProvider);
    get twin(): JDService;
    set twin(service: JDService);
    private handleTwinPacket;
    get registers(): JDRegisterServer<PackedValues>[];
    get timestamp(): number;
    register<TValues extends PackedValues = PackedValues>(code: number): JDRegisterServer<TValues>;
    protected addExistingRegister<TValues extends PackedValues = PackedValues>(reg: JDRegisterServer<TValues>): JDRegisterServer<TValues>;
    addRegister<TValues extends PackedValues = PackedValues>(identifier: number, defaultValue?: TValues): JDRegisterServer<TValues>;
    reset(): void;
    /**
     * Locks the current set of registers
     */
    lock(): void;
    protected addCommand(identifier: number, handler: (pkt: Packet) => void): void;
    handlePacket(pkt: Packet): Promise<void>;
    sendPacketAsync(pkt: Packet): Promise<void>;
    sendEvent(eventCode: number, data?: Uint8Array): Promise<void>;
    private handleCalibrate;
    processLargeFrame(command: string, data: Uint8Array): void;
    calibrate(): Promise<void>;
}
//# sourceMappingURL=serviceserver.d.ts.map