import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import Long from "long";
import { FixedPosFrameIdentifier, ScheduleTable, SignalValue, WriteFrame } from "./frame_params";
import { CanChannelConfiguration, DataProcessorNodeProperties, LinChannelConfiguration, LogFileFormat, MeasurementSetup, PeriodicTransmissionSettings, SourceNodeProperties, TargetNodeProperties } from "./measurement_settings";
/**
 * Possible events.
 * @internal
 */
export declare enum MeasurementEvent {
    MEASUREMENT_EVENT_UNSPECIFIED = 0,
    /** MEASUREMENT_EVENT_MEASUREMENT_SETUP_CHANGED - Raised when the measurement setup has changed, will pass the new MeasurementSetup as event data */
    MEASUREMENT_EVENT_MEASUREMENT_SETUP_CHANGED = 1,
    /** MEASUREMENT_EVENT_ONLINE_STATUS_CHANGED - Raised when the online status has changed, will pass the new OnlineStatus as event data */
    MEASUREMENT_EVENT_ONLINE_STATUS_CHANGED = 2,
    /** MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STARTED - Raised when a periodic transmission has started, will pass the transmission's identifier as event data */
    MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STARTED = 3,
    /** MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STOPPED - Raised when a periodic transmission has stopped, will pass the transmission's identifier as event data */
    MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STOPPED = 4,
    UNRECOGNIZED = -1
}
export declare function measurementEventFromJSON(object: any): MeasurementEvent;
export declare function measurementEventToJSON(object: MeasurementEvent): string;
/**
 * A request message for setting a new measurement setup.
 * @internal
 */
export interface SetMeasurementSetupRequest {
    setup: MeasurementSetup | undefined;
}
/**
 * A request message for adding all connected CAN channels.
 * @internal
 */
export interface AddAllConnectedCanChannelsRequest {
    configuration: CanChannelConfiguration | undefined;
}
/**
 * A request message for adding all connected LIN channels.
 * @internal
 */
export interface AddAllConnectedLinChannelsRequest {
    configuration: LinChannelConfiguration | undefined;
}
/**
 * A request message for adding or updating a source node.
 * @internal
 */
export interface AddOrUpdateSourceRequest {
    source: SourceNodeProperties | undefined;
    /**
     * If true then all properties will be replaced with values from source.
     * If false then only properties with values in source will be updated.
     * This field is ignored when adding a new node.
     */
    replaceAllProperties: boolean;
}
/**
 * A response message for getting a source node.
 * @internal
 */
export interface GetSourceResponse {
    source: SourceNodeProperties | undefined;
}
/**
 * A request message for adding or updating a data processor node.
 * @internal
 */
export interface AddOrUpdateDataProcessorRequest {
    dataProcessor: DataProcessorNodeProperties | undefined;
    /** If adding a new data processor after another node then set previous_node to the id of the preceding node */
    previousNode: string;
    /** If adding a new data processor before another node then set next_node to the id of the subsequent node */
    nextNode: string;
    /**
     * If true then all properties will be replaced with values from data_processor.
     * If false then only properties with values in data_processor will be updated.
     * This field is ignored when adding a new node.
     */
    replaceAllProperties: boolean;
}
/**
 * A response message for getting a data processor node.
 * @internal
 */
export interface GetDataProcessorResponse {
    dataProcessor: DataProcessorNodeProperties | undefined;
}
/**
 * A request message for adding or updating a target node.
 * @internal
 */
export interface AddOrUpdateTargetRequest {
    target: TargetNodeProperties | undefined;
    /**
     * If true then all properties will be replaced with values from target.
     * If false then only properties with values in target will be updated.
     * This field is ignored when adding a new node.
     */
    replaceAllProperties: boolean;
}
/**
 * A response message for getting a target node.
 * @internal
 */
export interface GetTargetResponse {
    target: TargetNodeProperties | undefined;
}
/**
 * A request message for connecting two nodes.
 * @internal
 */
export interface ConnectNodesRequest {
    startNode: string;
    endNode: string;
}
/**
 * A request message for disconnecting two nodes.
 * @internal
 */
export interface DisconnectNodesRequest {
    startNode: string;
    endNode: string;
}
/**
 * A request message for any service method that needs to know one identifier of a node
 * in the measurement setup.
 * @internal
 */
export interface IdentifierRequest {
    identifier: string;
}
/**
 * A request message for any service method that needs to know identifiers of a nodes
 * in the measurement setup.
 * @internal
 */
export interface IdentifiersRequest {
    identifiers: string[];
}
/**
 * A request message for sending out one message frame.
 * @internal
 */
export interface SendMessageRequest {
    channelIdentifier: string;
    frame: WriteFrame | undefined;
}
/**
 * A request message for sending out several message frames.
 * @internal
 */
export interface SendMessagesRequest {
    channelIdentifier: string;
    frames: WriteFrame[];
}
/**
 * A request message for sending out several message frames, spaced apart in time.
 * @internal
 */
export interface QueueMessagesRequest {
    /** Identifier of the channel to send the frames on. */
    channelIdentifier: string;
    /** The frames to send, in order. All frames must use the same protocol. */
    frames: WriteFrame[];
    /** The time, in milliseconds, to wait before the first frame is sent. 0 sends it immediately. */
    firstFrameTimeMs: number;
    /** The time, in milliseconds, to wait between consecutive frames. 0 sends them as fast as the channel accepts them. */
    separationTimeMs: number;
    /**
     * When false, the call returns once the last frame has been sent and a failed write fails the call.
     * When true, the call returns as soon as the batch has been queued.
     */
    noWait: boolean;
}
/**
 * A response message with the identifier of a queued transmission.
 * @internal
 */
export interface QueueMessagesResponse {
    queuedTransmissionIdentifier: string;
}
/**
 * The state of a queued transmission.
 * @internal
 */
export interface QueuedTransmission {
    /** Identifier of the queued transmission. */
    identifier: string;
    /** Identifier of the channel the frames are sent on. */
    channelIdentifier: string;
    /** The total number of frames in the batch. */
    totalFrames: number;
    /** The number of frames sent so far. */
    sentFrames: number;
    /** True when the batch has stopped, whether it completed, failed or was cancelled. */
    finished: boolean;
    /** Empty while the batch is running and after it has completed successfully. */
    error: string;
}
/**
 * A response message with the currently known queued transmissions.
 * @internal
 */
export interface GetQueuedTransmissionsResponse {
    transmissions: QueuedTransmission[];
}
/**
 * A request message for sending out one LIN wakeup frame.
 * @internal
 */
export interface SendLinWakeupFrameRequest {
    /** Identifier of the LIN channel to send the wakeup frame on. */
    channelIdentifier: string;
    /** The number of wakeup frames to send. Maximum value of count is 255 (0xFF). */
    count: number;
    /** The time, in bit times, between the wakeup frames. Maximum value of interval is either 255 (0xFF) or 65535 (0xFFFF) depending on device. */
    interval: number;
}
/**
 * A request message for writing a LIN message header to the LIN bus.
 * @internal
 */
export interface RequestLinMessageRequest {
    /** Identifier of the LIN channel to clear the message buffer on. */
    channelIdentifier: string;
    /** The LIN message id to write to the LIN bus. */
    frameId: number;
}
/**
 * A request message for updating a message buffer in a slave. The contents of the message buffer will be used the next time the slave
 * is polled for the specified LIN message id.
 * @internal
 */
export interface UpdateLinMessageRequest {
    /** Identifier of the LIN channel to update the message buffer on. */
    channelIdentifier: string;
    /** The new LIN message. */
    frame: WriteFrame | undefined;
}
/**
 * A request message for clearing a message buffer for a LIN slave. The slave will not answer next time it is polled.
 * @internal
 */
export interface ClearLinMessageRequest {
    /** Identifier of the LIN channel to clear the message buffer on. */
    channelIdentifier: string;
    /** The LIN message id for which the corresponding buffer will be cleared. */
    frameId: number;
}
/**
 * A request message for start sending out message frames periodically.
 * @internal
 */
export interface StartPeriodicTransmissionRequest {
    /** Periodic transmission settings */
    settings: PeriodicTransmissionSettings | undefined;
}
/**
 * A request message for updating the settings of a periodic transmission.
 * @internal
 */
export interface UpdatePeriodicTransmissionRequest {
    /** Periodic transmission settings */
    settings: PeriodicTransmissionSettings | undefined;
    /** Identifier of periodic transmission */
    identifier: string;
}
/**
 * A response message for start sending out message frames periodically.
 * @internal
 */
export interface StartPeriodicTransmissionResponse {
    periodicTransmissionIdentifier: string;
}
/** A message for streaming online status information. */
export interface OnlineStatus {
    /** Indicates if the measurement is online. */
    isOnline: boolean;
    /** Counter that is increased every time the measurement goes online. This can be used to detect when the measurement goes offline and then online again. */
    onlineCounter: number;
}
/**
 * Event arguments
 * @internal
 */
export interface MeasurementEventArgs {
    eventType: MeasurementEvent;
    identifier?: string | undefined;
    measurementSetup?: MeasurementSetup | undefined;
    onlineStatus?: OnlineStatus | undefined;
}
/**
 * A request message to get supported log file formats.
 * @internal
 */
export interface GetLogFileFormatsRequest {
    /** Set to true to include message log formats. */
    messageLog: boolean;
    /** Set to true to include signal value log formats. */
    signalLog: boolean;
    /** Set to true to only include formats with read support. */
    readSupport: boolean;
}
/**
 * Information about a log file format.
 * @internal
 */
export interface LogFileFormatInfo {
    /** File format. */
    format: LogFileFormat;
    /** File format name. */
    name: string;
    /** File format file extension. */
    extension: string;
    /** File format description. */
    description: string;
    /** Supported protocols by the format. */
    supportedProtocols: string[];
}
/**
 * A response message for GetLogFileFormats request.
 * @internal
 */
export interface GetLogFileFormatsResponse {
    /** All supported formats. */
    formats: LogFileFormatInfo[];
}
/**
 * A request message to get all channels listed in a log file.
 * @internal
 */
export interface GetChannelsFromLogFileRequest {
    /** Log file to retrieve channels from. */
    logFile: string;
}
/**
 * A response message for GetChannelsFromLogFile request.
 * @internal
 */
export interface GetChannelsFromLogFileResponse {
    /** Channels listed in the log file. */
    channels: number[];
    /** Channel protocols listed in the log file. */
    protocols: string[];
    /** True if the log file contains received frames. */
    hasRxFrames: boolean;
    /** True if the log file contains transmitted frames. */
    hasTxFrames: boolean;
}
/**
 * A request message to get all schedule tables listed in the specified database files.
 * @internal
 */
export interface GetScheduleTablesFromDatabaseFilesRequest {
    /** Database files to retrieve schedule tables from. */
    files: string[];
}
/**
 * A response message for GetScheduleTablesFromDatabaseFiles request.
 * @internal
 */
export interface GetScheduleTablesFromDatabaseFilesResponse {
    /** Tables listed in the database file. */
    tables: ScheduleTable[];
}
/**
 * A request message to get all signal values for a message.
 * @internal
 */
export interface GetSignalDataFromMessageDataRequest {
    /** Message qualified name. */
    messageQualifiedName: string;
    /** Message data. */
    data: number[];
}
/**
 * A response message for GetSignalDataFromMessageData request.
 * @internal
 */
export interface GetSignalDataFromMessageDataResponse {
    /** Signal values. */
    signalValues: SignalValue[];
}
/**
 * A request message to set all signal values for a message.
 * @internal
 */
export interface SetSignalDataToMessageDataRequest {
    /** Message qualified name. */
    messageQualifiedName: string;
    /** The current message data. */
    data: number[];
    /** New signal values. One or more signals to be updated. */
    signalValues: SignalValue[];
}
/**
 * A response message for SetSignalDataToMessageData request.
 * @internal
 */
export interface SetSignalDataToMessageDataResponse {
    /**
     * Updated signal values. Might be different from the once passed in the request if the
     * specified signal value couldn't be exactly represented in raw data.
     */
    signalValues: SignalValue[];
    /** Updated message data. */
    data: number[];
}
/**
 * A request message to get data frames before a specified timestamp.
 * @internal
 */
export interface GetDataFramesBeforeTimestampRequest {
    /** Maximum number of frames to retrieve. */
    maxCount?: number | undefined;
    /** Timestamp in microseconds to retrieve frames before. */
    timestampUs: Long;
}
/**
 * A request message to get data frames between specified timestamps.
 * @internal
 */
export interface GetDataFramesBetweenTimestampsRequest {
    /** Optional frame identifiers to filter on. If no frame identifiers are specified, frames from all identifiers are retrieved. */
    frameIds: FixedPosFrameIdentifier[];
    /** Timestamp in microseconds to retrieve frames from (inclusive). */
    startTimestampUs: Long;
    /** Timestamp in microseconds to retrieve frames to (exclusive). */
    endTimestampUs: Long;
}
/**
 * A request message to subscribe for data frames.
 * @internal
 */
export interface SubscribeForDataRequest {
    /** Subscribed frame identifiers, for frames specified here all data will be streamed. */
    frameIds: FixedPosFrameIdentifier[];
    /**
     * Subscribed signal qualified names, for frames carrying any of these signals all data will
     * be streamed. Use this rather than frame_ids for signal data: a frame resolved through PGN
     * lookup does not carry the identifier its database message has.
     */
    signalQualifiedNames: string[];
}
/**
 * A request message to get data envelopes between specified timestamps for specific frames.
 * @internal
 */
export interface GetFrameEnvelopesRequest {
    /** Timestamp in microseconds to retrieve envelopes from (inclusive). */
    startTimestampUs: Long;
    /** Timestamp in microseconds to retrieve envelopes to (exclusive). */
    endTimestampUs: Long;
    /** Width of the view in pixels. */
    viewWidthPx: number;
    /**
     * Optional frame identifiers to filter on. If no frame identifiers are specified, envelopes from all identifiers are retrieved.
     * Ignored when signal_qualified_names is non-empty.
     */
    frameIds: FixedPosFrameIdentifier[];
    /**
     * Optional signal qualified names to retrieve envelopes for. If specified, frame_ids is
     * ignored and the envelopes are returned in signal_envelopes rather than envelopes.
     * If no signal qualified names are specified, envelopes for all decodable signals are retrieved.
     */
    signalQualifiedNames: string[];
    /**
     * Optional source identifiers, positionally paired with signal_qualified_names. An empty or
     * absent entry merges every source that reports the signal into a single envelope.
     */
    sourceIdentifiers: string[];
}
/**
 * A data envelope for a specific signal.
 * All arrays must have the same length.
 * @internal
 */
export interface SignalDataEnvelope {
    /** Signal qualified name. */
    signalQualifiedName: string;
    /** Timestamps in microseconds. */
    timestampsUs: Long[];
    /** Minimum values. */
    minValues: number[];
    /** Maximum values. */
    maxValues: number[];
    /** Deprecated and never populated. Use MeasurementSignalEnvelope.source_identifier instead. */
    frameIds: FixedPosFrameIdentifier[];
}
export interface FrameDataEnvelope {
    /** Frame identifier. */
    frameId: FixedPosFrameIdentifier | undefined;
    /** Signal data envelopes for all signals in the frame. */
    signalEnvelopes: SignalDataEnvelope[];
}
/**
 * A data envelope for a specific signal, addressed by name rather than by frame identifier.
 * All arrays must have the same length.
 * @internal
 */
export interface MeasurementSignalEnvelope {
    /** Signal qualified name. */
    signalQualifiedName: string;
    /** Timestamps in microseconds. */
    timestampsUs: Long[];
    /** Minimum values. */
    minValues: number[];
    /** Maximum values. */
    maxValues: number[];
    /**
     * Identifier of the source node the signal was decoded from, empty when the envelope merges
     * every source that reports the signal.
     */
    sourceIdentifier: string;
}
/**
 * A response message for GetFrameEnvelopes request.
 * @internal
 */
export interface GetFrameEnvelopesResponse {
    /**
     * Data envelopes for all signals for each requested frame identifier.
     * Populated only when the request specified frame_ids.
     */
    envelopes: FrameDataEnvelope[];
    /**
     * Data envelopes for each requested signal qualified name.
     * Populated only when the request specified signal_qualified_names.
     */
    signalEnvelopes: MeasurementSignalEnvelope[];
}
/**
 * A collection of frame property names.
 * @internal
 */
export interface FramePropertyNames {
    /** The names of the frame properties. */
    names: string[];
}
/**
 * A response message for GetAvailableFramePropertyNames request.
 * @internal
 */
export interface GetAvailableFramePropertyNamesResponse {
    /**
     * Map of node type to available frame property names.
     * The node type can be used to determine which properties are available for frames processed by a specific node in the measurement setup.
     * Each node in the measurement setup has a node type, and the properties available for frames processed by that node depend on the node type.
     * For example, for frames processed by a CAN channel node, properties related to CAN frames will be available, while for frames processed by
     * a LIN channel node, properties related to LIN frames will be available.
     */
    framePropertyNamesByNodeType: {
        [key: string]: FramePropertyNames;
    };
}
export interface GetAvailableFramePropertyNamesResponse_FramePropertyNamesByNodeTypeEntry {
    key: string;
    value: FramePropertyNames | undefined;
}
/**
 * A request message for GetProtocolsInDatabaseFiles requests.
 * @internal
 */
export interface GetProtocolsInDatabaseFilesRequest {
    /** The database files to check. */
    files: string[];
}
/**
 * A response message for GetProtocolsInDatabaseFiles request.
 * @internal
 */
export interface GetProtocolsInDatabaseFilesResponse {
    /** The represented protocols. */
    protocols: string[];
}
/**
 * A request message for RunExtensionCommand requests.
 * @internal
 */
export interface RunExtensionCommandRequest {
    /** Identifier belonging to the extension node that will run the command. */
    extensionNodeId: string;
    /** The command identifier. */
    commandId: string;
    /** The command arguments. */
    commandArgs: string;
}
/**
 * A response message for RunExtensionCommand request.
 * @internal
 */
export interface RunExtensionCommandResponse {
    /** True if the command succeeded; otherwise false. */
    success: boolean;
    /** The success payload, or the error message on failure. */
    value: string;
}
export declare const SetMeasurementSetupRequest: MessageFns<SetMeasurementSetupRequest>;
export declare const AddAllConnectedCanChannelsRequest: MessageFns<AddAllConnectedCanChannelsRequest>;
export declare const AddAllConnectedLinChannelsRequest: MessageFns<AddAllConnectedLinChannelsRequest>;
export declare const AddOrUpdateSourceRequest: MessageFns<AddOrUpdateSourceRequest>;
export declare const GetSourceResponse: MessageFns<GetSourceResponse>;
export declare const AddOrUpdateDataProcessorRequest: MessageFns<AddOrUpdateDataProcessorRequest>;
export declare const GetDataProcessorResponse: MessageFns<GetDataProcessorResponse>;
export declare const AddOrUpdateTargetRequest: MessageFns<AddOrUpdateTargetRequest>;
export declare const GetTargetResponse: MessageFns<GetTargetResponse>;
export declare const ConnectNodesRequest: MessageFns<ConnectNodesRequest>;
export declare const DisconnectNodesRequest: MessageFns<DisconnectNodesRequest>;
export declare const IdentifierRequest: MessageFns<IdentifierRequest>;
export declare const IdentifiersRequest: MessageFns<IdentifiersRequest>;
export declare const SendMessageRequest: MessageFns<SendMessageRequest>;
export declare const SendMessagesRequest: MessageFns<SendMessagesRequest>;
export declare const QueueMessagesRequest: MessageFns<QueueMessagesRequest>;
export declare const QueueMessagesResponse: MessageFns<QueueMessagesResponse>;
export declare const QueuedTransmission: MessageFns<QueuedTransmission>;
export declare const GetQueuedTransmissionsResponse: MessageFns<GetQueuedTransmissionsResponse>;
export declare const SendLinWakeupFrameRequest: MessageFns<SendLinWakeupFrameRequest>;
export declare const RequestLinMessageRequest: MessageFns<RequestLinMessageRequest>;
export declare const UpdateLinMessageRequest: MessageFns<UpdateLinMessageRequest>;
export declare const ClearLinMessageRequest: MessageFns<ClearLinMessageRequest>;
export declare const StartPeriodicTransmissionRequest: MessageFns<StartPeriodicTransmissionRequest>;
export declare const UpdatePeriodicTransmissionRequest: MessageFns<UpdatePeriodicTransmissionRequest>;
export declare const StartPeriodicTransmissionResponse: MessageFns<StartPeriodicTransmissionResponse>;
export declare const OnlineStatus: MessageFns<OnlineStatus>;
export declare const MeasurementEventArgs: MessageFns<MeasurementEventArgs>;
export declare const GetLogFileFormatsRequest: MessageFns<GetLogFileFormatsRequest>;
export declare const LogFileFormatInfo: MessageFns<LogFileFormatInfo>;
export declare const GetLogFileFormatsResponse: MessageFns<GetLogFileFormatsResponse>;
export declare const GetChannelsFromLogFileRequest: MessageFns<GetChannelsFromLogFileRequest>;
export declare const GetChannelsFromLogFileResponse: MessageFns<GetChannelsFromLogFileResponse>;
export declare const GetScheduleTablesFromDatabaseFilesRequest: MessageFns<GetScheduleTablesFromDatabaseFilesRequest>;
export declare const GetScheduleTablesFromDatabaseFilesResponse: MessageFns<GetScheduleTablesFromDatabaseFilesResponse>;
export declare const GetSignalDataFromMessageDataRequest: MessageFns<GetSignalDataFromMessageDataRequest>;
export declare const GetSignalDataFromMessageDataResponse: MessageFns<GetSignalDataFromMessageDataResponse>;
export declare const SetSignalDataToMessageDataRequest: MessageFns<SetSignalDataToMessageDataRequest>;
export declare const SetSignalDataToMessageDataResponse: MessageFns<SetSignalDataToMessageDataResponse>;
export declare const GetDataFramesBeforeTimestampRequest: MessageFns<GetDataFramesBeforeTimestampRequest>;
export declare const GetDataFramesBetweenTimestampsRequest: MessageFns<GetDataFramesBetweenTimestampsRequest>;
export declare const SubscribeForDataRequest: MessageFns<SubscribeForDataRequest>;
export declare const GetFrameEnvelopesRequest: MessageFns<GetFrameEnvelopesRequest>;
export declare const SignalDataEnvelope: MessageFns<SignalDataEnvelope>;
export declare const FrameDataEnvelope: MessageFns<FrameDataEnvelope>;
export declare const MeasurementSignalEnvelope: MessageFns<MeasurementSignalEnvelope>;
export declare const GetFrameEnvelopesResponse: MessageFns<GetFrameEnvelopesResponse>;
export declare const FramePropertyNames: MessageFns<FramePropertyNames>;
export declare const GetAvailableFramePropertyNamesResponse: MessageFns<GetAvailableFramePropertyNamesResponse>;
export declare const GetAvailableFramePropertyNamesResponse_FramePropertyNamesByNodeTypeEntry: MessageFns<GetAvailableFramePropertyNamesResponse_FramePropertyNamesByNodeTypeEntry>;
export declare const GetProtocolsInDatabaseFilesRequest: MessageFns<GetProtocolsInDatabaseFilesRequest>;
export declare const GetProtocolsInDatabaseFilesResponse: MessageFns<GetProtocolsInDatabaseFilesResponse>;
export declare const RunExtensionCommandRequest: MessageFns<RunExtensionCommandRequest>;
export declare const RunExtensionCommandResponse: MessageFns<RunExtensionCommandResponse>;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & {
    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
};
interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};