import type { Declared, Directives, InterfaceDescriptor, Label, Properties, Semantics } from "../registry/types.js";
/** What a declaration can set for any interface. */
export interface CommonOptions {
    /** The name of the instance of a generic controller: "Blind.Lift", "Fan.Speed". */
    instance?: string;
    /** What the user calls the instance; the first name is the one the Alexa app shows. */
    friendlyNames?: Label[];
    /** The properties are in the answer to ReportState. Default: true. */
    retrievable?: boolean;
    /** A change of the properties is sent to Alexa as a ChangeReport. Default: false. */
    proactivelyReported?: boolean;
    /** The user can ask for the properties and cannot set them. Left out of discovery when not given. */
    nonControllable?: boolean;
}
/** The same as a schema. The friendly names are checked with the instance, by the rules of the interface. */
export declare const commonOptions: import("../registry/schema.js").Schema<import("../registry/schema.js").InferShape<{
    instance: import("../registry/schema.js").OptionalSchema<string>;
    friendlyNames: import("../registry/schema.js").OptionalSchema<unknown[]>;
    retrievable: import("../registry/schema.js").OptionalSchema<boolean>;
    proactivelyReported: import("../registry/schema.js").OptionalSchema<boolean>;
    nonControllable: import("../registry/schema.js").OptionalSchema<boolean>;
}>>;
type Naming<I extends boolean> = I extends true ? {
    instance: string;
    friendlyNames: Label[];
} : {
    instance?: string;
    friendlyNames?: Label[];
};
/** The options of device.add() for one interface: its own, and the ones every interface has. */
export type Declaration<O, I extends boolean> = O & Omit<CommonOptions, "instance" | "friendlyNames"> & Naming<I>;
/** A capability object of a discovery answer (alexa-discovery-objects.html, "Capability object"). */
export interface CapabilityJson {
    type: "AlexaInterface";
    interface: string;
    instance?: string;
    version: string;
    properties?: {
        supported: Array<{
            name: string;
        }>;
        proactivelyReported: boolean;
        retrievable: boolean;
        nonControllable?: boolean;
    };
    capabilityResources?: {
        friendlyNames: Label[];
    };
    configuration?: Record<string, unknown>;
    configurations?: Record<string, unknown>;
    semantics?: Semantics;
    [field: string]: unknown;
}
/** One interface as an endpoint declares it: the descriptor, and what the declaration says about this endpoint. */
export declare class Capability<P extends Properties = Properties, D extends Directives = Directives, O = {}> implements Declared<O> {
    readonly descriptor: InterfaceDescriptor<P, D, O, boolean>;
    /** The endpoint the capability is declared on; the device sets it. */
    endpointId: string;
    /** "" for an interface without instances. */
    instance: string;
    friendlyNames: Label[];
    retrievable: boolean;
    proactivelyReported: boolean;
    nonControllable?: boolean;
    /** The options of the interface: a range, the supported modes, the semantics. */
    options: O;
    /** What the bridge logs about the declaration, once, when it answers a discovery. */
    readonly notes: string[];
    constructor(descriptor: InterfaceDescriptor<P, D, O, boolean>, declared: CommonOptions & {
        options: O;
    });
    get namespace(): string;
    /** Mappings of "open", "close", "raise", "lower" and of states, when the declaration has any. */
    get semantics(): Semantics | undefined;
    /** The capability object for discovery, its fields in the order of the example on alexa-discovery-objects.html. */
    toJSON(): CapabilityJson;
}
export type AnyCapability = Capability<any, any, any>;
export {};