homebridge-homeconnect/dist/has-programs.d.ts

A Homebridge plugin that connects Home Connect appliances to Apple HomeKit

import { Service } from 'homebridge';
import { ApplianceBase } from './appliance-generic.js';
import { Constructor } from './utils.js';
import { OptionValues, ProgramKey } from './api-value-types.js';
import { OptionDefinitionKV, OptionKey, OptionValue, ProgramDefinitionKV } from './api-value.js';
import { Value } from './api-types.js';
import { ApplianceProgramConfig } from './config-types.js';
import { SchemaProgramOption } from './homebridge-ui/schema-data.js';
import { SerialisedOperation } from './serialised.js';
export interface CheckedProgramConfig extends Omit<ApplianceProgramConfig, 'options'> {
    key: ProgramKey;
    options?: OptionValues;
}
export interface UpdateProgramHCValue {
    startCurrent?: true;
    startNamed?: {
        name: string;
        key: ProgramKey;
        options: OptionValues;
    };
    selectNamed?: {
        name: string;
        key: ProgramKey;
        options: OptionValues;
    };
    stop?: true;
    pause?: boolean;
}
type UpdateProgramHC = SerialisedOperation<UpdateProgramHCValue>;
declare const RELATIVE_OPTION_KEY: readonly ["BSH.Common.Option.StartInRelative", "BSH.Common.Option.FinishInRelative"];
type RelativeOptionKey<Index extends number = 0 | 1> = typeof RELATIVE_OPTION_KEY[Index];
export declare function HasPrograms<TBase extends Constructor<ApplianceBase & {
    activeService?: Service;
}>>(Base: TBase): {
    new (...args: any[]): {
        readonly programService: Service[];
        programs: (ProgramDefinitionKV & {
            selected?: boolean;
        })[];
        supportsPowerOn: boolean;
        autoSelectingPrograms: boolean;
        initHasPrograms(): Promise<void>;
        initPrograms(): Promise<void>;
        refreshPrograms(active?: boolean): Promise<void>;
        missingOptionsHelp(programs: ProgramDefinitionKV[]): void;
        updateProgramsWithoutSelecting(programKeys: ProgramKey[]): Promise<void>;
        updateProgramsSelectFirst(programKeys: ProgramKey[]): Promise<void>;
        updateCachedProgram<Key extends ProgramKey>(details: ProgramDefinitionKV<Key>, selected: boolean): void;
        selectAndGetAvailableProgram<Key extends ProgramKey>(programKey: Key): Promise<ProgramDefinitionKV<Key>>;
        getAvailableProgram<Key extends ProgramKey>(programKey: Key): Promise<ProgramDefinitionKV<Key>>;
        requireProgramReady(programKey: ProgramKey): void;
        savePrograms(): Promise<void>;
        updateSelectedProgram(programKey: ProgramKey | null): Promise<void>;
        addAllPrograms(updateProgramHC: UpdateProgramHC): void;
        addConfiguredPrograms(config: ApplianceProgramConfig[], updateProgramHC: UpdateProgramHC): void;
        assertIsProgramKey<Key extends ProgramKey>(programKey: string): asserts programKey is Key;
        assertIsOptionKey<Key extends OptionKey>(programKey: ProgramKey, optionKey: string): asserts optionKey is Key;
        assertIsOptionValue<Key extends OptionKey>(programKey: ProgramKey, optionKey: Key, value: string | number | boolean): asserts value is OptionValue<Key>;
        addPrograms(programs: CheckedProgramConfig[], updateProgramHC: UpdateProgramHC): void;
        updateProgramHC(value: UpdateProgramHCValue): Promise<void>;
        addProgram({ name, key, selectonly, options }: CheckedProgramConfig, updateProgramHC: UpdateProgramHC): Service;
        addActiveProgramControl(supportsPause: boolean | undefined, supportsResume: boolean | undefined, updateProgramHC: UpdateProgramHC): void;
        identify(): Promise<void>;
        makeConfigOption<Key extends OptionKey>(option: OptionDefinitionKV<Key>): Record<string, unknown>;
        setSchemaPrograms(allPrograms: ProgramDefinitionKV[]): Promise<void>;
        setSchemaProgramOptions<Key extends ProgramKey>(program: ProgramDefinitionKV<Key>): Promise<void>;
        makeSchemaOption<Key extends OptionKey>(option: OptionDefinitionKV<Key>): SchemaProgramOption;
        makeName(name: string | undefined, key: ProgramKey | Value): string;
        simpleName(name: string | undefined, key: string): string;
        isOptionRelative(key: OptionKey): key is RelativeOptionKey;
        timeToSeconds(value: string | number): number;
        readonly Service: typeof Service;
        readonly Characteristic: typeof import("homebridge").Characteristic;
        readonly config: import("./config-types.js").ApplianceConfig;
        readonly schema: import("./homebridge-ui/schema-data.js").ConfigSchemaData;
        readonly optionalFeatures: import("./homebridge-ui/schema-data.js").SchemaOptionalFeature[];
        readonly cache: import("./persist-cache.js").PersistCache;
        readonly cachedOperation: Record<string, string>;
        readonly cachedPromise: Map<string, Promise<unknown>>;
        readonly asyncInitTasks: {
            name: string;
            promise: Promise<void>;
        }[];
        serviceNames: import("./service-name.js").ServiceNames;
        readonly accessoryInformationService: Service;
        readonly obsoleteServices: Service[];
        disconnectedHapStatusError: boolean;
        readonly log: import("homebridge").Logger;
        readonly platform: import("./platform.js").HomeConnectPlatform;
        readonly device: import("./homeconnect-device.js").HomeConnectDevice;
        readonly accessory: import("homebridge").PlatformAccessory;
        asyncInitialise(name: string, promise: Promise<void>): void;
        waitAsyncInitialisation(): Promise<void>;
        makeService(serviceConstructor: typeof Service & {
            new (displayName?: string, subtype?: string): Service;
            UUID: string;
        }, suffix?: string, subtype?: string): Service;
        cleanupServices(): void;
        cleanupOldVersions(): void;
        unregister(): void;
        hasOptionalFeature(service: string, name: string, group?: string, enableByDefault?: boolean): boolean;
        setOptionalFeatures(): Promise<void>;
        getCached<Type>(key: string, operation: () => Promise<Type>): Promise<Type>;
        doCachedOperation<Type>(key: string, operation: () => Promise<Type>): Promise<Type>;
        makeSerialised<Value extends import("./serialised.js").SerialisedValue, Returns = void>(operation: SerialisedOperation<Value, Returns>, defaultValue?: Value): (value?: Value) => Promise<Returns>;
        makeSerialisedObject<Value extends object, Returns = void>(operation: SerialisedOperation<Value, Returns>): (value?: Value) => Promise<Returns>;
        registerDisconnectedOnGet(): void;
        onGet(characteristic: import("homebridge").Characteristic): import("homebridge").Nullable<import("homebridge").CharacteristicValue>;
        onSet<Type>(assertIsType: (value: unknown) => asserts value is Type, characteristic: import("homebridge").Characteristic, handler: import("./appliance-generic.js").OnSetHandler<Type>): import("homebridge").Characteristic;
        onSetBoolean(args_0: import("homebridge").Characteristic, args_1: import("./appliance-generic.js").OnSetHandler<boolean>): import("homebridge").Characteristic;
        onSetNumber(args_0: import("homebridge").Characteristic, args_1: import("./appliance-generic.js").OnSetHandler<number>): import("homebridge").Characteristic;
        onSetString(args_0: import("homebridge").Characteristic, args_1: import("./appliance-generic.js").OnSetHandler<string>): import("homebridge").Characteristic;
        activeService?: Service;
    };
} & TBase;
export {};
//# sourceMappingURL=has-programs.d.ts.map