import { type CompanionHTTPRequest, type CompanionHTTPResponse, type CompanionOptionValues, type CompanionStaticUpgradeScript, type InstanceConstructor, type InstanceTypes, type JsonValue, type SomeCompanionConfigField } from '@companion-module/base';
import type { SharedUdpSocketMessage } from '@companion-module/base/host-api';
import type { ActionInstance, FeedbackInstance, ModuleHostContext, UpgradeActionAndFeedbackInstancesResponse, UpgradeActionInstance, UpgradeFeedbackInstance } from './context.js';
export declare class InstanceWrapper<TManifest extends InstanceTypes> {
    #private;
    constructor(id: string, host: ModuleHostContext<TManifest['config'], TManifest['secrets']>, instanceFactory: InstanceConstructor<TManifest>, upgradeScripts: CompanionStaticUpgradeScript<TManifest['config'], TManifest['secrets']>[], moduleApiVersion: string);
    init(msg: InitMessage): Promise<InitResponseMessage>;
    destroy(): Promise<void>;
    configUpdateAndLabel(label: string, config: TManifest['config'], secrets: TManifest['secrets']): Promise<void>;
    /**
     * @deprecated use executeActionWithSignal instead, which allows passing an AbortSignal to the action callback, so that it can be cancelled if needed
     */
    executeAction(action: ActionInstance, surfaceId: string | undefined): Promise<ExecuteActionResult>;
    executeActionWithSignal(action: ActionInstance, surfaceId: string | undefined, signal: AbortSignal): Promise<ExecuteActionResult>;
    updateFeedbacks(feedbacks: Record<string, FeedbackInstance | null | undefined>): Promise<void>;
    updateActions(actions: Record<string, ActionInstance | null | undefined>): Promise<void>;
    upgradeActionsAndFeedbacks(defaultUpgradeIndex: number | null, actions: UpgradeActionInstance[], feedbacks: UpgradeFeedbackInstance[]): Promise<UpgradeActionAndFeedbackInstancesResponse>;
    getConfigFields(): Promise<SomeCompanionConfigField[]>;
    httpRequest(request: CompanionHTTPRequest): Promise<CompanionHTTPResponse>;
    /**
     * @deprecated use learnActionWithSignal instead, which allows passing an AbortSignal to the learn function, so that it can be cancelled if needed
     */
    learnAction(action: ActionInstance): Promise<{
        options: CompanionOptionValues | undefined;
    }>;
    learnActionWithSignal(action: ActionInstance, signal: AbortSignal): Promise<{
        options: CompanionOptionValues | undefined;
    }>;
    /**
     * @deprecated use learnFeedbackWithSignal instead, which allows passing an AbortSignal to the learn function, so that it can be cancelled if needed
     */
    learnFeedback(feedback: FeedbackInstance): Promise<{
        options: CompanionOptionValues | undefined;
    }>;
    learnFeedbackWithSignal(feedback: FeedbackInstance, signal: AbortSignal): Promise<{
        options: CompanionOptionValues | undefined;
    }>;
    startStopRecordActions(recording: boolean): Promise<void>;
    sharedUdpSocketMessage(msg: SharedUdpSocketMessage): Promise<void>;
    sharedUdpSocketError(msg: SharedUdpSocketError): Promise<void>;
}
export interface InitMessage {
    label: string;
    isFirstInit: boolean;
    config: unknown;
    secrets: unknown;
    lastUpgradeIndex: number;
}
export interface InitResponseMessage {
    hasHttpHandler: boolean;
    hasRecordActionsHandler: boolean;
    newUpgradeIndex: number;
    disableNewConfigLayout: boolean;
    updatedConfig: unknown | undefined;
    updatedSecrets: unknown | undefined;
}
export interface ExecuteActionSuccess {
    success: true;
    /**
     * The result returned by the callback, or `undefined` if the callback
     * doesn't return a result.
     */
    result: JsonValue | undefined;
}
export interface ExecuteActionFailure {
    success: false;
    /** A reason for the failure */
    errorMessage: string;
}
export type ExecuteActionResult = ExecuteActionSuccess | ExecuteActionFailure;
export interface SharedUdpSocketError {
    handleId: string;
    portNumber: number;
    errorMessage: string;
    errorStack: string | undefined;
}
//# sourceMappingURL=instance.d.ts.map