/// <reference types="node" />

import type { BinaryReadOptions } from '@protobuf-ts/runtime';
import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
import type { IBinaryReader } from '@protobuf-ts/runtime';
import type { IBinaryWriter } from '@protobuf-ts/runtime';
import { MessageType } from '@protobuf-ts/runtime';
import { Observable } from 'rxjs';
import type { PartialMessage } from '@protobuf-ts/runtime';
import { Subject } from 'rxjs';

/**
 * / permissions
 *
 * @generated from protobuf enum cr.AccessLevel
 */
export declare enum AccessLevel {
    /**
     * /< No permission
     *
     * @generated from protobuf enum value: NO_ACCESS = 0;
     */
    NO_ACCESS = 0,
    /**
     * /< Read permission
     *
     * @generated from protobuf enum value: READ = 1;
     */
    READ = 1,
    /**
     * /< Write permission
     *
     * @generated from protobuf enum value: WRITE = 2;
     */
    WRITE = 2,
    /**
     * /< Read and write permission
     *
     * @generated from protobuf enum value: READ_WRITE = 3;
     */
    READ_WRITE = 3
}

declare class AhsokaMessageHeader$Type extends MessageType<AhsokaMessageHeader> {
    constructor();
    create(value?: PartialMessage<AhsokaMessageHeader>): AhsokaMessageHeader;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AhsokaMessageHeader): AhsokaMessageHeader;
    internalBinaryWrite(message: AhsokaMessageHeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / This Service Routing Message Header is used in the OpenPV system.
 * / Reach can speak it.
 * / This object represents the Layer 2 Message Format for OpenPV Service Messages.
 * / The ordinals are presereved but the names are changed to match
 *
 * @generated from protobuf message cr.AhsokaMessageHeader
 */
export declare interface AhsokaMessageHeader {
    /**
     * / This ID defines the Type of Message being carried in the Envelope / Header
     * / Called transport_id in OpenPV terminology.
     * / Called message_type in Reach terms.
     *
     * @generated from protobuf field: int32 message_type = 1;
     */
    messageType: number;
    /**
     * / This ID defines a unique Message / Response used when out of order messages are needed
     * / Called transaction_id in the OpenPV system.
     * / Called transaction_id in Reach terms.
     *
     * @generated from protobuf field: int32 transaction_id = 2;
     */
    transactionId: number;
    /**
     * / Unique ID for a Client used in Services that support Multiple Clients
     * OpenPV would use a GUID but Reach uses a 4 byte integer
     *
     * @generated from protobuf field: bytes client_id = 3;
     */
    clientId: Uint8Array;
    /**
     * / Called message_size in the OpenPV system.
     * / Called remaining_objects in Reach terms
     * / In Reach it defines the number of objects that remain to be
     * / transmitted in a continuued transaction.
     * / The size of the message payload (in packets) that follows this header
     *
     * @generated from protobuf field: int32 remaining_objects = 4;
     */
    remainingObjects: number;
    /**
     * Routing for Non-Endpoint Style Transports.
     * Note: Endpoint 0 is Reserved for Service Discovery for Non-Endpoint Transports
     *
     * @generated from protobuf field: uint32 endpoint_id = 5;
     */
    endpointId: number;
    /**
     * / Not used or supported in Reach.
     * / In OpenPV, indicates that the message has used deflate compression in addition to pbuff encoding
     *
     * @generated from protobuf field: bool is_message_compressed = 6;
     */
    isMessageCompressed: boolean;
}

/**
 * @generated MessageType for protobuf message cr.AhsokaMessageHeader
 */
export declare const AhsokaMessageHeader: AhsokaMessageHeader$Type;

declare class BitfieldParameterInfo$Type extends MessageType<BitfieldParameterInfo> {
    constructor();
    create(value?: PartialMessage<BitfieldParameterInfo>): BitfieldParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BitfieldParameterInfo): BitfieldParameterInfo;
    internalBinaryWrite(message: BitfieldParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a bitfield
 *
 * @generated from protobuf message cr.BitfieldParameterInfo
 */
export declare interface BitfieldParameterInfo {
    /**
     * @generated from protobuf field: optional uint64 default_value = 1;
     */
    defaultValue?: bigint;
    /**
     * @generated from protobuf field: uint32 bits_available = 2;
     */
    bitsAvailable: number;
    /**
     * @generated from protobuf field: optional uint32 pei_id = 3;
     */
    peiId?: number;
}

/**
 * @generated MessageType for protobuf message cr.BitfieldParameterInfo
 */
export declare const BitfieldParameterInfo: BitfieldParameterInfo$Type;

declare class BoolParameterInfo$Type extends MessageType<BoolParameterInfo> {
    constructor();
    create(value?: PartialMessage<BoolParameterInfo>): BoolParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BoolParameterInfo): BoolParameterInfo;
    internalBinaryWrite(message: BoolParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a boolean
 *
 * @generated from protobuf message cr.BoolParameterInfo
 */
export declare interface BoolParameterInfo {
    /**
     * @generated from protobuf field: optional bool default_value = 1;
     */
    defaultValue?: boolean;
    /**
     * @generated from protobuf field: optional uint32 pei_id = 2;
     */
    peiId?: number;
}

/**
 * @generated MessageType for protobuf message cr.BoolParameterInfo
 */
export declare const BoolParameterInfo: BoolParameterInfo$Type;

declare class BufferSizes$Type extends MessageType<BufferSizes> {
    constructor();
    create(value?: PartialMessage<BufferSizes>): BufferSizes;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BufferSizes): BufferSizes;
    internalBinaryWrite(message: BufferSizes, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / This data describing the sizes of the structures used in C code is
 * / communicated in a packed format in the device info structure.
 * / Here it's defined in an unpacked (all 32 bit) format.  Use the offsets
 * / defined below (SizesOffsets) to unpack into this structure.
 * / The file "reach_ble_proto_sizes.h" and the function
 * / populate_device_info_sizes() are good places to look for further info.
 *
 * @generated from protobuf message cr.BufferSizes
 */
export declare interface BufferSizes {
    /**
     * / The largest message that can be communicated (16 bits)
     *
     * @generated from protobuf field: uint32 max_message_size = 1;
     */
    maxMessageSize: number;
    /**
     * / The size of the buffer used for the longest strings. (16 bits)
     * / Examples include the command line and the error string.
     *
     * @generated from protobuf field: uint32 big_data_buffer_size = 2;
     */
    bigDataBufferSize: number;
    /**
     * / The number of parameter buffers kept by the device.
     * / This determines the number of parameters that can be
     * / handled in a single message. (8 bits)
     *
     * @generated from protobuf field: uint32 parameter_buffer_count = 3;
     */
    parameterBufferCount: number;
    /**
     * / The number of parameter values that fit in one message. (8 bits)
     *
     * @generated from protobuf field: uint32 num_params_in_response = 4;
     */
    numParamsInResponse: number;
    /**
     * / The length of the description fields in various structures
     * / Previously known as long_string_len.   (8 bits)
     *
     * @generated from protobuf field: uint32 description_len = 6;
     */
    descriptionLen: number;
    /**
     * / The number of bytes in the largest parameter data.  (8 bits)
     *
     * @generated from protobuf field: uint32 max_param_bytes = 7;
     */
    maxParamBytes: number;
    /**
     * / The number of bytes in the param info description string  (8 bits)
     *
     * @generated from protobuf field: uint32 param_info_description_len = 10;
     */
    paramInfoDescriptionLen: number;
    /**
     * / The length of most (medium) strings.  (8 bits)
     * / Used for device name, file names, command names.
     *
     * @generated from protobuf field: uint32 medium_string_len = 8;
     */
    mediumStringLen: number;
    /**
     * / The number of bytes in short strings like the units label.  (8 bits)
     * / Also the names of enumerations and the version string.
     *
     * @generated from protobuf field: uint32 short_string_len = 9;
     */
    shortStringLen: number;
    /**
     * / number of descriptors (stream, file) that fit in one message.  (8 bits)
     *
     * @generated from protobuf field: uint32 num_descriptors_in_response = 5;
     */
    numDescriptorsInResponse: number;
    /**
     * / Number of parameter notifications supported  (8 bits)
     *
     * @generated from protobuf field: uint32 num_param_notifications = 11;
     */
    numParamNotifications: number;
    /**
     * / not currently used  (8 bits)
     *
     * @generated from protobuf field: uint32 num_commands_in_response = 13;
     */
    numCommandsInResponse: number;
    /**
     * / number of param descriptions that can be in one info packet. (8 bits)
     *
     * @generated from protobuf field: uint32 count_param_desc_in_response = 14;
     */
    countParamDescInResponse: number;
    /**
     * / The max number of parameter notification configurations
     * / that a client will provide.
     *
     * @generated from protobuf field: uint32 param_notify_config_count = 15;
     */
    paramNotifyConfigCount: number;
}

/**
 * @generated MessageType for protobuf message cr.BufferSizes
 */
export declare const BufferSizes: BufferSizes$Type;

declare class ByteArrayParameterInfo$Type extends MessageType<ByteArrayParameterInfo> {
    constructor();
    create(value?: PartialMessage<ByteArrayParameterInfo>): ByteArrayParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ByteArrayParameterInfo): ByteArrayParameterInfo;
    internalBinaryWrite(message: ByteArrayParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a byte array
 *
 * @generated from protobuf message cr.ByteArrayParameterInfo
 */
export declare interface ByteArrayParameterInfo {
    /**
     * @generated from protobuf field: optional bytes default_value = 1;
     */
    defaultValue?: Uint8Array;
    /**
     * @generated from protobuf field: uint32 max_size = 2;
     */
    maxSize: number;
}

/**
 * @generated MessageType for protobuf message cr.ByteArrayParameterInfo
 */
export declare const ByteArrayParameterInfo: ByteArrayParameterInfo$Type;

declare class CLIData$Type extends MessageType<CLIData> {
    constructor();
    create(value?: PartialMessage<CLIData>): CLIData;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CLIData): CLIData;
    internalBinaryWrite(message: CLIData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The optional Command Line Interface (CLI) service allows command line messages to be transfered
 * / between the client and the server.  Messages can travel in both directions.  Messages are asynchronous.
 * / The client can send a command line and the server can respond.
 * / The server can also asynchrously send strings representing the output of the device.
 * / The CLIData message is used in both directions.
 *
 * @generated from protobuf message cr.CLIData
 */
export declare interface CLIData {
    /**
     * @generated from protobuf field: string message_data = 1;
     */
    messageData: string;
}

/**
 * @generated MessageType for protobuf message cr.CLIData
 */
export declare const CLIData: CLIData$Type;

declare class CommandInfo$Type extends MessageType<CommandInfo> {
    constructor();
    create(value?: PartialMessage<CommandInfo>): CommandInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CommandInfo): CommandInfo;
    internalBinaryWrite(message: CommandInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The description of a command.
 *
 * @generated from protobuf message cr.CommandInfo
 */
export declare interface CommandInfo {
    /**
     * @generated from protobuf field: uint32 id = 1;
     */
    id: number;
    /**
     * @generated from protobuf field: string name = 2;
     */
    name: string;
    /**
     * @generated from protobuf field: optional string description = 3;
     */
    description?: string;
    /**
     * @generated from protobuf field: optional uint32 timeout = 4;
     */
    timeout?: number;
}

/**
 * @generated MessageType for protobuf message cr.CommandInfo
 */
export declare const CommandInfo: CommandInfo$Type;

/**
 * A CompletablePromise is a Promise whose fulfillment or rejection
 * can be triggered externally.
 *
 * @param T - the type of the object the promise can be fulfilled with.
 */
export declare class CompletablePromise<T> implements Promise<T>, PromiseLike<T> {
    /**
     * Create a new CompletablePromise that is already in the fulfilled state.
     *
     * @param value - the value to fulfill the promise with.
     */
    static resolved<U>(value: U): CompletablePromise<U>;
    [Symbol.toStringTag]: string;
    /** Backing promise object. */
    private promise;
    /** The current state of the backing promise object. */
    private stateField;
    /**
     * Construct a new CompletablePromise.
     */
    constructor();
    /**
     * Get the current state of the CompletablePromise.
     *
     * @returns 'pending' | 'resolved' | 'rejected'.
     */
    get state(): "pending" | "resolved" | "rejected";
    /**
     * Fulfill the completable promise with some value.
     *
     * @param value - The value to fulfill the promise with.
     */
    fulfill: (value: T | PromiseLike<T>) => void;
    /**
     * Reject the completable promise with an error.
     *
     * @param reason - The reason to reject the completable promise.
     */
    reject: (reason?: any) => void;
    /**
     * Attaches a single callback for both the resolution and rejection
     * of the promise.
     */
    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
    /**
     * Attaches callbacks for just the rejection of the Promise.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
    wait(): Promise<T>;
}

declare class ConnectionDescription$Type extends MessageType<ConnectionDescription> {
    constructor();
    create(value?: PartialMessage<ConnectionDescription>): ConnectionDescription;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ConnectionDescription): ConnectionDescription;
    internalBinaryWrite(message: ConnectionDescription, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure describing a WiFi connection or access point
 * / The optional WiFi service is intended to simplify the
 * / repetitive task of communicating WiFi credentials to the device.
 *
 * @generated from protobuf message cr.ConnectionDescription
 */
export declare interface ConnectionDescription {
    /**
     * @generated from protobuf field: string ssid = 1;
     */
    ssid: string;
    /**
     * @generated from protobuf field: bool is_connected = 2;
     */
    isConnected: boolean;
    /**
     * @generated from protobuf field: optional int32 signal_strength = 3;
     */
    signalStrength?: number;
    /**
     * @generated from protobuf field: optional cr.WiFiSecurity sec = 4;
     */
    sec?: WiFiSecurity;
    /**
     * @generated from protobuf field: optional cr.WiFiBand band = 5;
     */
    band?: WiFiBand;
}

/**
 * @generated MessageType for protobuf message cr.ConnectionDescription
 */
export declare const ConnectionDescription: ConnectionDescription$Type;

export declare const DEFAULT_MAX_BYTES_PER_MESSAGE: number;

export declare const DEFAULT_MAX_FILE_TRANSFER_BUFFER: number;

export declare const DEFAULT_MESSAGES_PER_ACK: number;

export declare const DEFAULT_PARAM_VALUES_PER_MESSAGE: number;

export declare const DEFAULT_TIMEOUT_MS: number;

export declare const DEFAULT_TRANSFER_BYTES: number;

export declare class DeviceAccess {
    private _networkAccess;
    protected onMessageSubject: Subject<ReachMessage>;
    protected onErrorReportSubject: Subject<{
        header: ReachMessageHeader;
        payload: ErrorReport;
    }>;
    protected onFileTransferSubject: Subject<FileTransfer>;
    protected onCliMesssageSubject: Subject<void>;
    /**
     * Observable fired whenever a Reach Protocol message is received.
     */
    onMessage$: Observable<ReachMessage>;
    /**
     * Observable fired whenever an error report message is received from the server.
     * The header and payload are both provided.
     */
    onErrorReport: Observable<{
        header: ReachMessageHeader;
        payload: ErrorReport;
    }>;
    /**
     * Observable fired upon successful completion of a file transfer.
     * The value associated with the event is the complete FileTransfer object, which will no longer be accessible in the fileTransfers map.
     */
    onFileTransfer$: Observable<FileTransfer>;
    /**
     * Observable fired whenever a CLI message is received.  The CLI messages are available in the cliMessages map.
     */
    onCliMessage$: Observable<void>;
    protected _classicHeaders: boolean;
    protected _transactionId: number;
    protected _clientId: number;
    protected _endpointId: number;
    protected _transactionTimeout: number;
    /**
     * This map is keyed off of the string generated by RequestID.key
     */
    protected _transactions: Map<string, Request_2<any>>;
    protected _deviceInfo: DeviceInfo | undefined;
    protected _paramInfos: Map<number, ParsedParameterInfo>;
    protected _paramValues: Map<number, ParameterValue>;
    protected _paramExtInfos: Map<number, ParameterExtendedInfo>;
    protected _paramNotifications: Map<number, ParameterNotifyConfig>;
    protected _commandInfos: Map<number, CommandInfo>;
    protected _cliMessages: Map<Date, CLIData>;
    protected _currentFileTransferId: number | undefined;
    protected _fileInfos: Map<number, FileInfo>;
    protected _fileTransfers: Map<number, FileTransfer>;
    protected _ackRate: number;
    protected _transferTimeout: number;
    protected _timeOffset: bigint | undefined;
    protected _timezone: number | undefined;
    /**
     * Creates a new system for interfacing with a Reach Protocol device.
     * @param _networkAccess - The implemented system for communicating with the device
     * @param classicHeaders - Whether the deprecated original Reach Protocol header format should be used.  Defaults to false.
     */
    constructor(_networkAccess: NetworkAccess, classicHeaders?: boolean);
    /**
     * General initialization of device communication.
     */
    init(): void;
    /**
     * Handles receipt of a Reach Protocol message, attempting to associate it with known transactions, and parsing any relevant data if it is not part of a known transaction.
     * @param binaryData - The raw data containing a Reach Protocol message
     */
    handleMessage(binaryData: ArrayBuffer): void;
    /**
     * Sends a provided Reach Protocol message via the transport method defined by NetworkAccess.
     * @param message - The message to be sent to the server.
     * @returns the result of sending the bytes via NetworkAccess
     */
    send(message: ReachMessage): Promise<void | Uint8Array>;
    /**
     * Sends a request with the specified category and payload, routing responses to the specified message handler.
     * Detailed configuration can be achieved through the config and mechanics arguments.
     * @typeParam T - The type expected to be returned upon a request being successfully fulfilled.
     * @param messageCategory - The category of message to be sent.
     * Unless otherwise specified in the config, responses to the initial message must be of this category to be considered valid.
     * @param payload - The payload for the message sent
     * @param onMessage - A handler for valid messages received as responses, returning an updated state for the request unless marked as stateless
     * @param config - High-level configuration for the request.
     * @param mechanics - Low-level configuration for the request.
     * @returns A Request with the specified configuration and typing
     */
    sendRequest<T>(messageCategory: ReachMessageTypes, messages: RequestMessage[] | RequestMessage, onMessage: (message: ReachMessage) => T, config?: Partial<RequestConfig>, mechanics?: Partial<RequestMechanics>): Promise<Request_2<T>>;
    /**
     * Sends a ping containing binary data to the server, waiting for a response from the server.
     * @param data - The data contained in the ping, which should be returned by the server.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns Upon a non-error response from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    ping(data: Uint8Array, config?: Partial<RequestConfig>): Promise<PingResponse>;
    /**
     * Sends a ping containing string data to the server, waiting for a response from the server.
     * @param data - The string included in the ping, which should be returned by the server.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The response upon successful receipt from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     * @remarks This is a wrapper for the {@link ping} method, encoding a string into raw bytes.
     */
    pingString(data: string, config?: Partial<RequestConfig>): Promise<PingResponse>;
    /**
     * Gets metadata from the device via a DeviceInfoRequest.
     * @param challengeKey - An optional challenge key sent to the device to grant modified access to services.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The metadata (DeviceInfo) upon a successful response from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    getDeviceInfo(challengeKey?: string, config?: Partial<RequestConfig>): Promise<DeviceInfo>;
    /**
     * Fetches core parameter information from the server.
     * @param parameterIds - A list of potential parameter IDs to be checked for.  An empty array means that all available parameters will be discovered.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns A map of parameter information upon successful receipt of responses from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     * @remarks If there are more parameter IDs provided than can be fit into a single message, a provided transaction ID will be incremented with each message.
     */
    discoverParameters(parameterIds?: number[], config?: Partial<RequestConfig>): Promise<Map<number, ParsedParameterInfo>>;
    /**
     * Fetches extended parameter information from the server.
     * @param paramExtInfoIds - A list of potential parameter extended info (PEI) IDs to be checked for.  An empty array means that all available PEI IDs will be discovered.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns A map of parameter extended info upon successful receipt of responses from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     * @remarks If there are more PEI IDs provided than can be fit into a single message, a provided transaction ID will be incremented with each message.
     */
    discoverParametersExt(paramExtInfoIds?: number[], config?: Partial<RequestConfig>): Promise<Map<number, ParameterExtendedInfo>>;
    /**
     * Reads the value of a single specified parameter.
     * @remarks The underlying message and response is equivalent to reading multiple parameters, and as such is not inherently optimized compared to that case.
     * @param parameterId - The parameter ID to be read.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The parameter value upon successful receipt of a response from the server.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     */
    readParameter(parameterId: number, config?: Partial<RequestConfig>): Promise<ParameterValue>;
    /**
     * Reads the values of the specified parameters, or all known parameters if no parameters are specified.
     * @param parameterIds - The parameter IDs to be read, reading all parameters if undefined or an empty array.  The array will be deduplicated before sending read requests.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns A map of parameter values upon successful receipt from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     * @remarks If there are more parameter IDs provided than can be fit into a single message, a provided transaction ID will be incremented with each message.
     */
    readParameters(parameterIds?: number[], config?: Partial<RequestConfig>): Promise<Map<number, ParameterValue>>;
    /**
     * Writes the specified parameter values to a server.
     * @param values - The values to be written.
     * @param parameterKey - Optional access key for the parameter(s) being written.
     * @param paramsPerMessage - Optional custom definition of the number of values written per message.
     * If a limit is known from device info, that limit will cap the number of values per message.
     * If not provided, a safe default will be chosen.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns Upon completion of the last write.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     * @remarks Internal accounting of parameter values is updated as writes are reported to be successful.
     */
    writeParameters(values?: ParameterValue[], paramsPerMessage?: number, config?: Partial<RequestConfig>): Promise<void>;
    /**
     * Gets the existing configuration of parameter notifications being tracked by the server.
     * @param parameterIds - The parameters to be checked for notifications.  If not provided, all parameters will be checked.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The current configuration of parameter notifications on the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    discoverParameterNotifs(parameterIds?: number[], config?: Partial<RequestConfig>): Promise<Map<number, ParameterNotifyConfig>>;
    /**
     * Enables parameter notifications on the device for the specified parameters.
     * @param toEnable - Settings for parameter notifications to be enabled.  Defaults to instant notifications on changes with a delta of 1.
     * @param disableAllFirst - Whether all existing parameter notifications should be disabled before enabling new notifications.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The resulting notification configuration, upon a successful response from the server
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    enableParameterNotifs(toEnable: Array<ParamNotifSettings>, disableAllFirst?: boolean, config?: Partial<RequestConfig>): Promise<Map<number, ParameterNotifyConfig>>;
    /**
     * Disables parameter notifications on the device for the specified parameters.
     * @param parameterIds - The parameters whose notifications are to be disabled.  If not provided, all notifications will be disabled.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The current configuration of parameter notifications on the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    disableParameterNotifs(parameterIds?: number[], config?: Partial<RequestConfig>): Promise<Map<number, ParameterNotifyConfig>>;
    /**
     * Fetches core information about files available to the client from the server.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns A map of file information upon successful receipt from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    discoverFiles(config?: Partial<RequestConfig>): Promise<Map<number, FileInfo>>;
    /**
     * Reads the specified file from the device, returning the file's data upon success.
     * @param fileID - The ID of the file to be read.
     * @param transferConfig - Configuration applying to the data transfer process.
     * @param requestConfig - General message configuration, applying only to init and completion messages if otherwise set in the transfer config.
     * @param initData - If reading a file with full data provided, data read from the device will be inserted starting at the provided byte offset.  Not generally used.
     * @returns The file data upon successful completion.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    readFile(fileID: number, transferConfig?: Partial<FileTransferConfig>, requestConfig?: Partial<RequestConfig>, initData?: Uint8Array): Promise<number[]>;
    /**
     * Writes the provided data to the specified file on the device.
     * @param fileID - The ID of the file to be written to.
     * @param data - The bytes to be written to the file.
     * If fullDataProvided is set in the transfer config, data will be pulled from the specified offset within this data rather than the beginning.
     * @param transferConfig - Configuration applying to the data transfer process.
     * @param requestConfig - General message configuration, applying only to init and completion messages if otherwise set in the transfer config.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    writeFile(fileID: number, data: Uint8Array, transferConfig?: Partial<FileTransferConfig>, requestConfig?: Partial<RequestConfig>): Promise<void>;
    /**
     * Sends a FileTransferInit to the device with the specified configuration
     * @param fileID - The ID of the file to be written to.
     * @param direction - The direction of the transfer being initated.
     * @param transferConfig - Configuration to be included in the init.
     * @param requestConfig - Configuration for how the init is sent to the device.
     * @returns The response from the device, or errors encountered or reported by the device.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    fileTransferInit(fileId: number, direction: FileTransferDirection, transferConfig?: Partial<FileTransferConfig>, requestConfig?: Partial<RequestConfig>): Promise<FileTransferResponse>;
    /**
     * Sends a FileTransferDataNotification message to the device and collects responses to the notification.
     * @param transferId - The ID of the transfer being notified about.
     * @param complete - If the transfer is being marked as complete.  Defaults to false.
     * @param config - Configuration for how the notification is sent to the device.
     * @param result - The result code to report to the device.  Defaults to 0 (no error).
     * @param errorMessage - An error message to report to the device.  Defaults to blank (no error).
     * @param retryOffset - A byte offset within the file transfer to allow the device to retry after an error.  System for use still undefined.
     * @returns The data reported by the device, or if sent as a complete transfer, the response from the device.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    transferDataNotification(transferId: number, complete?: boolean, config?: Partial<RequestConfig>, result?: number, errorMessage?: string, retryOffset?: number): Promise<number[] | FileTransferDataNotification>;
    /**
     * Sends a group of FileTransferData messages to the device and reports the device's response.
     * @param transferId - The ID of the transfer this data is associated with.
     * @param dataChunks - Groups of bytes to be sent to the device.
     * @param config - Configuration for how the messages are sent to the device.
     * @param checksums - RFC 1071 checksums for additional integrity verification.
     * @returns The response from the device.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    transferData(transferId: number, dataChunks: Uint8Array[], config?: Partial<RequestConfig>, checksums?: number[]): Promise<FileTransferDataNotification>;
    /**
     * Fetches information about predefined commands available to the client from the server.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns A map of command information upon successful receipt from the server.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    discoverCommands(config?: Partial<RequestConfig>): Promise<Map<number, CommandInfo>>;
    /**
     * Instructs the server to perform a specified command.
     * @param id - The ID of the command to be performed.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     */
    sendCommand(id: number, config?: Partial<RequestConfig>): Promise<void>;
    /**
     * Sends command line data to the device.
     * As the device does not provide a specific response to this command,
     * this function returns upon successfully sending the message via the transport.
     * @param data - The data to be sent to the device's command line.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The CLIData successfully sent.
     * @throws A descriptive error if no data is provided, and any errors produced when trying to send the Reach Protocol message.
     */
    sendCLIData(data: string, config?: Partial<RequestConfig>): Promise<CLIData>;
    /**
     * Sets the device's internal representation of time.
     * @remarks The DeviceAccess' timeOffset and timezone fields are not updated by this, due to variations in time service implementations.
     * @param time - The time to be set, offset as necessary if setting a raw time.
     * @param timezoneOffset - A timezone represented as an offset from UTC, in seconds.  Handling of undefined values is determined by the device.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns Upon a successful write.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     */
    setTime(time: Date, timezoneOffset?: number, config?: Partial<RequestConfig>): Promise<void>;
    /**
     * Gets the device's internal representation of time.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The response to the message, including the device time.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     */
    getTime(config?: Partial<RequestConfig>): Promise<TimeGetResponse>;
    /**
     * Fetches information about WiFi networks available to the server.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The response from the server upon success.
     * @throws A descriptive Error upon a transaction timeout or unexpected/error response from the server.
     */
    discoverWiFi(config?: Partial<RequestConfig>): Promise<DiscoverWiFiResponse>;
    /**
     * Attempts to connect to a specified WiFi network.
     * @param ssid - The SSID of the network to be connected to.
     * @param password - Password used to connect to the network.
     * @param autoconnect - Whether the server should automatically connect to this network.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The response from the server upon success.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     * @remarks This is a wrapper for the {@link setWiFiConnection} method, which more directly reflects the Reach Protocol message sent to the server.
     */
    connectWiFi(ssid: string, password: string, autoconnect: boolean, config?: Partial<RequestConfig>): Promise<WiFiConnectionResponse>;
    /**
     * Attempts to disconnect from a specified WiFi network.
     * @param ssid - The SSID of the network to disconnect from.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @returns The response from the server upon success.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     * @remarks This is a wrapper for the {@link setWiFiConnection} method, which more directly reflects the Reach Protocol message sent to the server.
     */
    disconnectWiFi(ssid: string, config?: Partial<RequestConfig>): Promise<WiFiConnectionResponse>;
    /**
     * Sends a WiFi connection request to the device, and reports the response upon success.
     * @param ssid - The ID of the network to connect to/disconnect from
     * @param connect - Whether the specified network should be connected to.
     * @param disconnect - Whether the specified network should be disconnected from.
     * @param config - Optional configuration of the Reach Protocol message being sent.
     * @param password - If connecting, the password to be used to connect to the network.
     * @param autoconnect - If connection is successful, whether this network should be automatically connected to.
     * @returns The response from the server, including the RSSI of the network.
     * @throws A descriptive Error upon a transaction timeout or error response from the server.
     * @remarks
     * If called with connect and disconnect set to false, information about the network will be returned without action.
     * The meaning of a message with both connect and disconnect set to true has not been agreed upon at this stage.
     * One option would be for the server to disconnect from any current network(s) and connect to the network specified.
     */
    setWiFiConnection(ssid: string, connect: boolean, disconnect: boolean, config?: Partial<RequestConfig>, password?: string, autoconnect?: boolean): Promise<WiFiConnectionResponse>;
    handlePing(message: ReachMessage): PingResponse;
    handleDeviceInfo(message: ReachMessage): DeviceInfo;
    handleDiscoverParameters(message: ReachMessage): Map<number, ParsedParameterInfo>;
    handleDiscoverParametersExt(message: ReachMessage): Map<number, ParameterExtendedInfo>;
    /**
     * Processes an incoming ReachMessage, both updating the global paramValues map and returning a map of the received values (adding onto the existing state if it represents part of an ongoing transaction).
     * @param message - The ReachMessage to be processed, assumed to contain a ParameterReadResponse in the payload.
     * @returns A map of the ParameterValues received in the payload, potentially including values received in previous messages from the transaction.
     */
    handleReadParameters(message: ReachMessage): Map<number, ParameterValue>;
    handleWriteParameters(message: ReachMessage): void;
    handleDiscoverParameterNotifs(message: ReachMessage): Map<number, ParameterNotifyConfig>;
    handleConfigParamNotify(message: ReachMessage): void;
    handleParameterNotification(message: ReachMessage): void;
    handleDiscoverFiles(message: ReachMessage): Map<number, FileInfo>;
    handleTransferInit(message: ReachMessage): FileTransferResponse;
    handleTransferData(message: ReachMessage): {
        data: number[];
        messageNumber: number;
    };
    handleTransferDataNotification(message: ReachMessage): FileTransferDataNotification;
    handleDiscoverCommands(message: ReachMessage): Map<number, CommandInfo>;
    handleSendCommand(message: ReachMessage): void;
    handleCliNotification(message: ReachMessage): void;
    handleSetTime(message: ReachMessage): void;
    handleGetTime(message: ReachMessage): TimeGetResponse;
    handleDiscoverWiFi(message: ReachMessage): DiscoverWiFiResponse;
    handleWiFiConnection(message: ReachMessage): WiFiConnectionResponse;
    handleErrorReport(message: ReachMessage): {
        header: ReachMessageHeader;
        payload: ErrorReport;
    };
    protected generalErrorHelper(category: string, payload?: any): void;
    protected responseErrorHelper(category: string, payload?: {
        result: number;
        resultMessage?: string;
    }): void;
    /** Setters & Getters */
    /**
     * The version of the Reach Protocol the DeviceAccess object is built around.
     */
    get reachProtoVersion(): ProtoVersion;
    /**
     * Configures if messages sent should use the deprecated classic header format.
     */
    get classicHeaders(): boolean;
    set classicHeaders(classic: boolean);
    /**
     * The unique transaction ID for an interaction with a Reach device
     */
    get transactionId(): number;
    set transactionId(id: number);
    /**
     * The unique ID for a client of a Reach device
     */
    get clientId(): number;
    set clientId(id: number);
    /**
     * The ID for an endpoint within a Reach device
     */
    get endpointId(): number;
    set endpointId(value: number);
    /**
     * The timeout for a Reach message, in ms.
     * If a transaction is not acknowledged in some way within this period, the associated Request will error out.
     */
    get transactionTimeout(): number;
    set transactionTimeout(value: number);
    /**
     * Transactions made with the server (device)
     */
    get transactions(): Map<string, Request_2<any>>;
    set transactions(value: Map<string, Request_2<any>>);
    /**
     * The most recently received DeviceInfo from a server.
     */
    get deviceInfo(): DeviceInfo | undefined;
    set deviceInfo(deviceInfo: DeviceInfo | undefined);
    /**
     * Known commands reported by the server, keyed by command ID.
     */
    get commandInfos(): Map<number, CommandInfo>;
    set commandInfos(commandInfos: Map<number, CommandInfo>);
    hasCommandInfo(commandId: number): boolean;
    getCommandInfo(commandId: number): CommandInfo | undefined;
    setCommandInfo(commandId: number, commandInfo: CommandInfo): void;
    /**
     * @deprecated Use fileInfos instead. This method will be removed in future versions.
     */
    get fileInfoMap(): Map<number, FileInfo>;
    /**
     * Known files reported by the server, keyed by file ID.
     */
    get fileInfos(): Map<number, FileInfo>;
    /**
     * @deprecated Use fileInfos instead. This method will be removed in future versions.
     */
    set fileInfoMap(fileInfoMap: Map<number, FileInfo>);
    set fileInfos(fileInfoMap: Map<number, FileInfo>);
    /**
     * @deprecated Use fileTransfers instead. This method will be removed in future versions.
     */
    get fileTransferMap(): Map<number, FileTransfer>;
    /**
     * Known ongoing file transfers, keyed by transfer ID.
     */
    get fileTransfers(): Map<number, FileTransfer>;
    /**
     * @deprecated Use fileTransfers instead. This method will be removed in future versions.
     */
    set fileTransferMap(fileTransfers: Map<number, FileTransfer>);
    set fileTransfers(fileTransfers: Map<number, FileTransfer>);
    hasFileTransfer(transferId: number): boolean;
    getFileTransfer(transferId: number): FileTransfer | undefined;
    setFileTransfer(transferId: number, fileTransfer: FileTransfer): void;
    /**
     * The ID of the file transfer currently in progress, if one exists.
     */
    get currentFileTransferId(): number | undefined;
    set currentFileTransferId(id: number | undefined);
    /**
     * The network connection used to communicate with a Reach Protocol device.
     */
    get networkAccess(): NetworkAccess;
    /**
     * Known parameter info from the server, keyed by parameter ID.
     */
    get paramInfos(): Map<number, ParsedParameterInfo>;
    set paramInfos(paramInfos: Map<number, ParsedParameterInfo>);
    isParamInfosEmpty(): boolean;
    hasParamInfo(parameterId: number): boolean;
    getParamInfo(parameterId: number): ParsedParameterInfo | undefined;
    setParamInfo(parameterId: number, paramInfo: ParameterInfo): void;
    clearParamInfos(): void;
    /**
     * Known parameter extended info from the server, keyed by PEI ID.
     */
    get paramExtInfos(): Map<number, ParameterExtendedInfo>;
    set paramExtInfos(paramExtensions: Map<number, ParameterExtendedInfo>);
    /**
     * Known parameter values from the server, keyed by parameter ID.
     */
    get paramValues(): Map<number, ParameterValue>;
    set paramValues(paramValues: Map<number, ParameterValue>);
    getParamValue(parameterId: number): ParameterValue | undefined;
    setParamValue(parameterId: number, paramValue: ParameterValue): void;
    get paramNotifications(): Map<number, ParameterNotifyConfig>;
    /**
     * Known active parameter notifications, keyed by parameter ID.
     */
    set paramNotifications(value: Map<number, ParameterNotifyConfig>);
    /**
     * CLI data received from the server or sent by the client, keyed by the timestamp of receipt/sending
     */
    get cliMessages(): Map<Date, CLIData>;
    set cliMessages(messages: Map<Date, CLIData>);
    /**
     * The acknowledgement rate for file transfers.
     */
    get ackRate(): number;
    set ackRate(ackRate: number);
    /**
     * Timeout for file transfer messages, in ms
     */
    get transferTimeout(): number;
    set transferTimeout(timeoutMs: number);
    /**
     Device's reported time as an offset in seconds from the system time, or undefined if not read.
     */
    get timeOffset(): bigint | undefined;
    set timeOffset(offset: bigint | undefined);
    /**
     Device's reported timezone as an offset from UTC in seconds.
     Undefined if time unread or the device does not have a persistent timezone.
     */
    get timezone(): number | undefined;
    set timezone(tz: number | undefined);
    /**
     Device's time in UTC, or undefined if unread.
     */
    get deviceTime(): Date | undefined;
}

export declare class DeviceInfo implements DeviceInfoResponse {
    protocolVersionString: string;
    deviceName: string;
    manufacturer: string;
    deviceDescription: string;
    firmwareVersion: string;
    services: number;
    parameterMetadataHash: number;
    applicationIdentifier?: Uint8Array | undefined;
    endpoints: number;
    sizesStruct: Uint8Array;
    private _bufferSizes;
    get bufferSizes(): BufferSizes;
    parsedProtoVersion: ProtoVersion;
    constructor(data: DeviceInfoResponse);
    private setBufferSizes;
    private parseBlock;
    private parseProtoVersion;
}

declare class DeviceInfoRequest$Type extends MessageType<DeviceInfoRequest> {
    constructor();
    create(value?: PartialMessage<DeviceInfoRequest>): DeviceInfoRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeviceInfoRequest): DeviceInfoRequest;
    internalBinaryWrite(message: DeviceInfoRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Required Device Information Service
 * / Reach sessions are opened with the device info request and response.
 *
 * @generated from protobuf message cr.DeviceInfoRequest
 */
export declare interface DeviceInfoRequest {
    /**
     * @generated from protobuf field: optional string challenge_key = 1;
     */
    challengeKey?: string;
    /**
     * @generated from protobuf field: string client_protocol_version = 2;
     */
    clientProtocolVersion: string;
}

/**
 * @generated MessageType for protobuf message cr.DeviceInfoRequest
 */
export declare const DeviceInfoRequest: DeviceInfoRequest$Type;

declare class DeviceInfoResponse$Type extends MessageType<DeviceInfoResponse> {
    constructor();
    create(value?: PartialMessage<DeviceInfoResponse>): DeviceInfoResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeviceInfoResponse): DeviceInfoResponse;
    internalBinaryWrite(message: DeviceInfoResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / This message is returned in answer to the first "who are you" query from the client.
 *
 * @generated from protobuf message cr.DeviceInfoResponse
 */
export declare interface DeviceInfoResponse {
    /**
     * @generated from protobuf field: string device_name = 2;
     */
    deviceName: string;
    /**
     * @generated from protobuf field: string manufacturer = 3;
     */
    manufacturer: string;
    /**
     * @generated from protobuf field: string device_description = 4;
     */
    deviceDescription: string;
    /**
     * / Each endpoint advertises a "main" FW version.
     * / If there are other FW versions, put them in the parameter repo.
     *
     * @generated from protobuf field: string firmware_version = 6;
     */
    firmwareVersion: string;
    /**
     * @generated from protobuf field: string protocol_version_string = 7;
     */
    protocolVersionString: string;
    /**
     * @generated from protobuf field: uint32 services = 8;
     */
    services: number;
    /**
     * @generated from protobuf field: uint32 parameter_metadata_hash = 9;
     */
    parameterMetadataHash: number;
    /**
     * @generated from protobuf field: optional bytes application_identifier = 10;
     */
    applicationIdentifier?: Uint8Array;
    /**
     * @generated from protobuf field: uint32 endpoints = 11;
     */
    endpoints: number;
    /**
     * @generated from protobuf field: bytes sizes_struct = 20;
     */
    sizesStruct: Uint8Array;
}

/**
 * @generated MessageType for protobuf message cr.DeviceInfoResponse
 */
export declare const DeviceInfoResponse: DeviceInfoResponse$Type;

declare class DiscoverCommands$Type extends MessageType<DiscoverCommands> {
    constructor();
    create(value?: PartialMessage<DiscoverCommands>): DiscoverCommands;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverCommands): DiscoverCommands;
    internalBinaryWrite(message: DiscoverCommands, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The (optional) Command Service allows actions to be triggered from the Reach UI.
 *
 * @generated from protobuf message cr.DiscoverCommands
 */
export declare interface DiscoverCommands {
}

/**
 * @generated MessageType for protobuf message cr.DiscoverCommands
 */
export declare const DiscoverCommands: DiscoverCommands$Type;

declare class DiscoverCommandsResponse$Type extends MessageType<DiscoverCommandsResponse> {
    constructor();
    create(value?: PartialMessage<DiscoverCommandsResponse>): DiscoverCommandsResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverCommandsResponse): DiscoverCommandsResponse;
    internalBinaryWrite(message: DiscoverCommandsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Response to a DiscoverCommands request.
 *
 * @generated from protobuf message cr.DiscoverCommandsResponse
 */
export declare interface DiscoverCommandsResponse {
    /**
     * @generated from protobuf field: repeated cr.CommandInfo available_commands = 1;
     */
    availableCommands: CommandInfo[];
}

/**
 * @generated MessageType for protobuf message cr.DiscoverCommandsResponse
 */
export declare const DiscoverCommandsResponse: DiscoverCommandsResponse$Type;

declare class DiscoverFiles$Type extends MessageType<DiscoverFiles> {
    constructor();
    create(value?: PartialMessage<DiscoverFiles>): DiscoverFiles;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverFiles): DiscoverFiles;
    internalBinaryWrite(message: DiscoverFiles, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The optional file service provides a method of efficiently transfering large blocks of data.
 *
 * @generated from protobuf message cr.DiscoverFiles
 */
export declare interface DiscoverFiles {
}

/**
 * @generated MessageType for protobuf message cr.DiscoverFiles
 */
export declare const DiscoverFiles: DiscoverFiles$Type;

declare class DiscoverFilesResponse$Type extends MessageType<DiscoverFilesResponse> {
    constructor();
    create(value?: PartialMessage<DiscoverFilesResponse>): DiscoverFilesResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverFilesResponse): DiscoverFilesResponse;
    internalBinaryWrite(message: DiscoverFilesResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to discover files
 *
 * @generated from protobuf message cr.DiscoverFilesResponse
 */
export declare interface DiscoverFilesResponse {
    /**
     * @generated from protobuf field: repeated cr.FileInfo file_infos = 1;
     */
    fileInfos: FileInfo[];
}

/**
 * @generated MessageType for protobuf message cr.DiscoverFilesResponse
 */
export declare const DiscoverFilesResponse: DiscoverFilesResponse$Type;

declare class DiscoverParameterNotifications$Type extends MessageType<DiscoverParameterNotifications> {
    constructor();
    create(value?: PartialMessage<DiscoverParameterNotifications>): DiscoverParameterNotifications;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverParameterNotifications): DiscoverParameterNotifications;
    internalBinaryWrite(message: DiscoverParameterNotifications, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The client can discover how notifications are setup.
 *
 * @generated from protobuf message cr.DiscoverParameterNotifications
 */
export declare interface DiscoverParameterNotifications {
    /**
     * @generated from protobuf field: repeated uint32 parameter_ids = 1;
     */
    parameterIds: number[];
}

/**
 * @generated MessageType for protobuf message cr.DiscoverParameterNotifications
 */
export declare const DiscoverParameterNotifications: DiscoverParameterNotifications$Type;

declare class DiscoverParameterNotificationsResponse$Type extends MessageType<DiscoverParameterNotificationsResponse> {
    constructor();
    create(value?: PartialMessage<DiscoverParameterNotificationsResponse>): DiscoverParameterNotificationsResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverParameterNotificationsResponse): DiscoverParameterNotificationsResponse;
    internalBinaryWrite(message: DiscoverParameterNotificationsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Reports which notifications are enabled.
 *
 * @generated from protobuf message cr.DiscoverParameterNotificationsResponse
 */
export declare interface DiscoverParameterNotificationsResponse {
    /**
     * @generated from protobuf field: repeated cr.ParameterNotifyConfig configs = 1;
     */
    configs: ParameterNotifyConfig[];
}

/**
 * @generated MessageType for protobuf message cr.DiscoverParameterNotificationsResponse
 */
export declare const DiscoverParameterNotificationsResponse: DiscoverParameterNotificationsResponse$Type;

declare class DiscoverStreams$Type extends MessageType<DiscoverStreams> {
    constructor();
    create(value?: PartialMessage<DiscoverStreams>): DiscoverStreams;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverStreams): DiscoverStreams;
    internalBinaryWrite(message: DiscoverStreams, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A request to list the streams supported by the device
 *
 * @generated from protobuf message cr.DiscoverStreams
 */
export declare interface DiscoverStreams {
}

/**
 * @generated MessageType for protobuf message cr.DiscoverStreams
 */
export declare const DiscoverStreams: DiscoverStreams$Type;

declare class DiscoverStreamsResponse$Type extends MessageType<DiscoverStreamsResponse> {
    constructor();
    create(value?: PartialMessage<DiscoverStreamsResponse>): DiscoverStreamsResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverStreamsResponse): DiscoverStreamsResponse;
    internalBinaryWrite(message: DiscoverStreamsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to DiscoverStreams
 *
 * @generated from protobuf message cr.DiscoverStreamsResponse
 */
export declare interface DiscoverStreamsResponse {
    /**
     * @generated from protobuf field: repeated cr.StreamInfo streams = 1;
     */
    streams: StreamInfo[];
}

/**
 * @generated MessageType for protobuf message cr.DiscoverStreamsResponse
 */
export declare const DiscoverStreamsResponse: DiscoverStreamsResponse$Type;

declare class DiscoverWiFi$Type extends MessageType<DiscoverWiFi> {
    constructor();
    create(value?: PartialMessage<DiscoverWiFi>): DiscoverWiFi;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverWiFi): DiscoverWiFi;
    internalBinaryWrite(message: DiscoverWiFi, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A request to provide a list access points
 *
 * @generated from protobuf message cr.DiscoverWiFi
 */
export declare interface DiscoverWiFi {
}

/**
 * @generated MessageType for protobuf message cr.DiscoverWiFi
 */
export declare const DiscoverWiFi: DiscoverWiFi$Type;

declare class DiscoverWiFiResponse$Type extends MessageType<DiscoverWiFiResponse> {
    constructor();
    create(value?: PartialMessage<DiscoverWiFiResponse>): DiscoverWiFiResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiscoverWiFiResponse): DiscoverWiFiResponse;
    internalBinaryWrite(message: DiscoverWiFiResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / response to DiscoverWiFi
 *
 * @generated from protobuf message cr.DiscoverWiFiResponse
 */
export declare interface DiscoverWiFiResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: repeated cr.ConnectionDescription cd = 2;
     */
    cd: ConnectionDescription[];
}

/**
 * @generated MessageType for protobuf message cr.DiscoverWiFiResponse
 */
export declare const DiscoverWiFiResponse: DiscoverWiFiResponse$Type;

/**
 * / binary bit masks or'ed together into the DeviceInfoResponse.endpoints
 *
 * @generated from protobuf enum cr.EndpointIds
 */
export declare enum EndpointIds {
    /**
     * /< No other endpoints
     *
     * @generated from protobuf enum value: NO_ENDPOINTS = 0;
     */
    NO_ENDPOINTS = 0,
    /**
     * /< This is the first of multiple endpoints.
     *
     * @generated from protobuf enum value: ONE = 1;
     */
    ONE = 1,
    /**
     * /< This is the second of multiple endpoints.
     *
     * @generated from protobuf enum value: TWO = 2;
     */
    TWO = 2,
    /**
     * /< This is the third of multiple endpoints.
     *
     * @generated from protobuf enum value: THREE = 4;
     */
    THREE = 4,
    /**
     * /< This is the fourth of multiple endpoints.
     *
     * @generated from protobuf enum value: FOUR = 8;
     */
    FOUR = 8
}

declare class EnumParameterInfo$Type extends MessageType<EnumParameterInfo> {
    constructor();
    create(value?: PartialMessage<EnumParameterInfo>): EnumParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumParameterInfo): EnumParameterInfo;
    internalBinaryWrite(message: EnumParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes an enumerated value
 *
 * @generated from protobuf message cr.EnumParameterInfo
 */
export declare interface EnumParameterInfo {
    /**
     * @generated from protobuf field: optional uint32 range_min = 1;
     */
    rangeMin?: number;
    /**
     * @generated from protobuf field: optional uint32 range_max = 2;
     */
    rangeMax?: number;
    /**
     * @generated from protobuf field: optional uint32 default_value = 3;
     */
    defaultValue?: number;
    /**
     * @generated from protobuf field: optional uint32 pei_id = 4;
     */
    peiId?: number;
    /**
     * @generated from protobuf field: optional string units = 5;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.EnumParameterInfo
 */
export declare const EnumParameterInfo: EnumParameterInfo$Type;

/**
 * / Reach uses these error codes.
 *
 * @generated from protobuf enum cr.ErrorCodes
 */
export declare enum ErrorCodes {
    /**
     * /< Normal conclusion, no problem.
     *
     * @generated from protobuf enum value: NO_ERROR = 0;
     */
    NO_ERROR = 0,
    /**
     * /< No data was produced
     *
     * @generated from protobuf enum value: NO_DATA = 1;
     */
    NO_DATA = 1,
    /**
     * /< The read failed.
     *
     * @generated from protobuf enum value: READ_FAILED = 2;
     */
    READ_FAILED = 2,
    /**
     * /< The write failed.
     *
     * @generated from protobuf enum value: WRITE_FAILED = 3;
     */
    WRITE_FAILED = 3,
    /**
     * /< returned by weak implementations
     *
     * @generated from protobuf enum value: NOT_IMPLEMENTED = 4;
     */
    NOT_IMPLEMENTED = 4,
    /**
     * /< not yet used
     *
     * @generated from protobuf enum value: RESERVED_1 = 5;
     */
    RESERVED_1 = 5,
    /**
     * /< not yet used
     *
     * @generated from protobuf enum value: RESERVED_2 = 6;
     */
    RESERVED_2 = 6,
    /**
     * /< access not allowed
     *
     * @generated from protobuf enum value: PERMISSION_DENIED = 7;
     */
    PERMISSION_DENIED = 7,
    /**
     * /< Requested a size larger than the buffer.
     *
     * @generated from protobuf enum value: BUFFER_TOO_SMALL = 8;
     */
    BUFFER_TOO_SMALL = 8,
    /**
     * /< Some function parameter is out of range
     *
     * @generated from protobuf enum value: INVALID_PARAMETER = 9;
     */
    INVALID_PARAMETER = 9,
    /**
     * /< Received data does not match checksum
     *
     * @generated from protobuf enum value: CHECKSUM_MISMATCH = 10;
     */
    CHECKSUM_MISMATCH = 10,
    /**
     * /< Protobuf decoding failed
     *
     * @generated from protobuf enum value: DECODING_FAILED = 11;
     */
    DECODING_FAILED = 11,
    /**
     * /< Protobuf encoding failed
     *
     * @generated from protobuf enum value: ENCODING_FAILED = 12;
     */
    ENCODING_FAILED = 12,
    /**
     * /< The current state machine does not handle this case.
     *
     * @generated from protobuf enum value: INVALID_STATE = 13;
     */
    INVALID_STATE = 13,
    /**
     * /< handler signals no response is necessary
     *
     * @generated from protobuf enum value: NO_RESPONSE = 14;
     */
    NO_RESPONSE = 14,
    /**
     * /< bad file ID
     *
     * @generated from protobuf enum value: BAD_FILE = 15;
     */
    BAD_FILE = 15,
    /**
     * /< A received packet has an unexpected serial number
     *
     * @generated from protobuf enum value: PACKET_COUNT_ERR = 16;
     */
    PACKET_COUNT_ERR = 16,
    /**
     * /< Access denied due to challenge key
     *
     * @generated from protobuf enum value: CHALLENGE_FAILED = 17;
     */
    CHALLENGE_FAILED = 17,
    /**
     * /< not yet used
     *
     * @generated from protobuf enum value: RESERVED_3 = 18;
     */
    RESERVED_3 = 18,
    /**
     * /< Some required resource is not available.
     *
     * @generated from protobuf enum value: NO_RESOURCE = 19;
     */
    NO_RESOURCE = 19,
    /**
     * /< The ID provided is not valid
     *
     * @generated from protobuf enum value: INVALID_ID = 20;
     */
    INVALID_ID = 20,
    /**
     * /< The requested operation is incomplete and must be retried.
     *
     * @generated from protobuf enum value: INCOMPLETE = 21;
     */
    INCOMPLETE = 21,
    /**
     * /< Operation cancellation
     *
     * @generated from protobuf enum value: ABORT = 1000;
     */
    ABORT = 1000
}

declare class ErrorReport$Type extends MessageType<ErrorReport> {
    constructor();
    create(value?: PartialMessage<ErrorReport>): ErrorReport;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ErrorReport): ErrorReport;
    internalBinaryWrite(message: ErrorReport, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / ERROR_REPORT: Could be sent asynchronously to indicate an error.
 *
 * @generated from protobuf message cr.ErrorReport
 */
export declare interface ErrorReport {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: string result_message = 2;
     */
    resultMessage: string;
}

/**
 * @generated MessageType for protobuf message cr.ErrorReport
 */
export declare const ErrorReport: ErrorReport$Type;

declare class FileEraseRequest$Type extends MessageType<FileEraseRequest> {
    constructor();
    create(value?: PartialMessage<FileEraseRequest>): FileEraseRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileEraseRequest): FileEraseRequest;
    internalBinaryWrite(message: FileEraseRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A request to erase (set size to zero) a file.
 *
 * @generated from protobuf message cr.FileEraseRequest
 */
export declare interface FileEraseRequest {
    /**
     * @generated from protobuf field: uint32 file_id = 1;
     */
    fileId: number;
}

/**
 * @generated MessageType for protobuf message cr.FileEraseRequest
 */
export declare const FileEraseRequest: FileEraseRequest$Type;

declare class FileEraseResponse$Type extends MessageType<FileEraseResponse> {
    constructor();
    create(value?: PartialMessage<FileEraseResponse>): FileEraseResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileEraseResponse): FileEraseResponse;
    internalBinaryWrite(message: FileEraseResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to a file erase request
 *
 * @generated from protobuf message cr.FileEraseResponse
 */
export declare interface FileEraseResponse {
    /**
     * @generated from protobuf field: uint32 file_id = 1;
     */
    fileId: number;
    /**
     * @generated from protobuf field: int32 result = 2;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 3;
     */
    resultMessage?: string;
}

/**
 * @generated MessageType for protobuf message cr.FileEraseResponse
 */
export declare const FileEraseResponse: FileEraseResponse$Type;

declare class FileInfo$Type extends MessageType<FileInfo> {
    constructor();
    create(value?: PartialMessage<FileInfo>): FileInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileInfo): FileInfo;
    internalBinaryWrite(message: FileInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure describing a file
 *
 * @generated from protobuf message cr.FileInfo
 */
export declare interface FileInfo {
    /**
     * @generated from protobuf field: uint32 file_id = 1;
     */
    fileId: number;
    /**
     * @generated from protobuf field: string file_name = 2;
     */
    fileName: string;
    /**
     * @generated from protobuf field: cr.AccessLevel access = 3;
     */
    access: AccessLevel;
    /**
     * @generated from protobuf field: int32 current_size_bytes = 4;
     */
    currentSizeBytes: number;
    /**
     * @generated from protobuf field: optional uint32 maximum_size_bytes = 7;
     */
    maximumSizeBytes?: number;
    /**
     * @generated from protobuf field: cr.StorageLocation storage_location = 5;
     */
    storageLocation: StorageLocation;
    /**
     * @generated from protobuf field: bool require_checksum = 6;
     */
    requireChecksum: boolean;
}

/**
 * @generated MessageType for protobuf message cr.FileInfo
 */
export declare const FileInfo: FileInfo$Type;

export declare class FileTransfer {
    protected _transferID: number;
    protected _fileID: number;
    protected _offset: number;
    /**
     * The length of the file being transferred
     */
    protected _transferLength: number;
    /**
     * Whether the full data for a file transfer has been provided, including data before the offset and/or data past the transfer length.
     * If true, data will be read from/inserted beginning at the index specified by the offset.  Defaults to false.
     */
    protected _fullDataProvided: boolean;
    protected _direction: FileTransferDirection;
    protected _ackRate: number;
    protected _timeout: number;
    protected _state: FileTransferState;
    /**
     * Keeps track of how many file data messages have been transferred between acks
     */
    protected _transferDataCount: number;
    /**
     * The amount of bytes that have been read
     */
    protected _bytesTransferred: number;
    protected _fileData: number[];
    constructor(direction: FileTransferDirection, fileID: number, config?: Partial<FileTransferConfig>, data?: number[]);
    /** Setters & Getters */
    get transferID(): number;
    get fileID(): number;
    get direction(): FileTransferDirection;
    get transferLength(): number;
    get offset(): number;
    /**
     * Whether the full data for a file transfer has been provided, including data before the offset and/or data past the transfer length.
     * If true, data will be read from/inserted beginning at the index specified by the offset.  Defaults to false.
     */
    get fullDataProvided(): boolean;
    get ackRate(): number;
    set ackRate(rate: number);
    get timeout(): number;
    set timeout(timeout: number);
    get state(): FileTransferState;
    set state(state: FileTransferState);
    protected get configLocked(): boolean;
    get fileData(): number[];
    set fileData(data: number[]);
    get bytesTransferred(): number;
    set bytesTransferred(bytes: number);
    addFileData(data: number[]): void;
}

export declare interface FileTransferConfig {
    /**
     * The number of messages sent before an acknowledgement is expected from the server.
     */
    ackRate: number;
    /**
     * The timeout for receiving responses from the server upon the last client message in a transaction, in ms.
     */
    timeout: number;
    requireChecksum: boolean;
    transferID: number;
    transferLength: number;
    offset: number;
    /**
     * Whether the full data for a file transfer is being provided, including data before the offset and/or data past the transfer length.
     * If true, data will be read from/inserted beginning at the index specified by the offset.
     */
    fullDataProvided: boolean;
}

declare class FileTransferData$Type extends MessageType<FileTransferData> {
    constructor();
    create(value?: PartialMessage<FileTransferData>): FileTransferData;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileTransferData): FileTransferData;
    internalBinaryWrite(message: FileTransferData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A bidirectional message describing a packet of file data
 *
 * @generated from protobuf message cr.FileTransferData
 */
export declare interface FileTransferData {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: uint32 transfer_id = 2;
     */
    transferId: number;
    /**
     * @generated from protobuf field: uint32 message_number = 3;
     */
    messageNumber: number;
    /**
     * @generated from protobuf field: bytes message_data = 4;
     */
    messageData: Uint8Array;
    /**
     * @generated from protobuf field: optional int32 checksum = 5;
     */
    checksum?: number;
}

/**
 * @generated MessageType for protobuf message cr.FileTransferData
 */
export declare const FileTransferData: FileTransferData$Type;

declare class FileTransferDataNotification$Type extends MessageType<FileTransferDataNotification> {
    constructor();
    create(value?: PartialMessage<FileTransferDataNotification>): FileTransferDataNotification;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileTransferDataNotification): FileTransferDataNotification;
    internalBinaryWrite(message: FileTransferDataNotification, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to a file transfer
 *
 * @generated from protobuf message cr.FileTransferDataNotification
 */
export declare interface FileTransferDataNotification {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 2;
     */
    resultMessage?: string;
    /**
     * @generated from protobuf field: bool is_complete = 3;
     */
    isComplete: boolean;
    /**
     * @generated from protobuf field: uint32 transfer_id = 4;
     */
    transferId: number;
    /**
     * @generated from protobuf field: uint32 retry_offset = 5;
     */
    retryOffset: number;
}

/**
 * @generated MessageType for protobuf message cr.FileTransferDataNotification
 */
export declare const FileTransferDataNotification: FileTransferDataNotification$Type;

export declare const enum FileTransferDirection {
    DOWNLOAD = 0,
    UPLOAD = 1
}

declare class FileTransferRequest$Type extends MessageType<FileTransferRequest> {
    constructor();
    create(value?: PartialMessage<FileTransferRequest>): FileTransferRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileTransferRequest): FileTransferRequest;
    internalBinaryWrite(message: FileTransferRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Begins a File Transfer (Upload / Download)
 *
 * @generated from protobuf message cr.FileTransferRequest
 */
export declare interface FileTransferRequest {
    /**
     * @generated from protobuf field: uint32 file_id = 1;
     */
    fileId: number;
    /**
     * @generated from protobuf field: uint32 read_write = 2;
     */
    readWrite: number;
    /**
     * @generated from protobuf field: uint32 request_offset = 3;
     */
    requestOffset: number;
    /**
     * @generated from protobuf field: uint32 transfer_length = 4;
     */
    transferLength: number;
    /**
     * @generated from protobuf field: uint32 transfer_id = 5;
     */
    transferId: number;
    /**
     * @generated from protobuf field: uint32 timeout_in_ms = 7;
     */
    timeoutInMs: number;
    /**
     * @generated from protobuf field: optional uint32 requested_ack_rate = 8;
     */
    requestedAckRate?: number;
    /**
     * @generated from protobuf field: bool require_checksum = 9;
     */
    requireChecksum: boolean;
}

/**
 * @generated MessageType for protobuf message cr.FileTransferRequest
 */
export declare const FileTransferRequest: FileTransferRequest$Type;

declare class FileTransferResponse$Type extends MessageType<FileTransferResponse> {
    constructor();
    create(value?: PartialMessage<FileTransferResponse>): FileTransferResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileTransferResponse): FileTransferResponse;
    internalBinaryWrite(message: FileTransferResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to a file transfer request
 *
 * @generated from protobuf message cr.FileTransferResponse
 */
export declare interface FileTransferResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: uint32 transfer_id = 2;
     */
    transferId: number;
    /**
     * @generated from protobuf field: uint32 ack_rate = 3;
     */
    ackRate: number;
    /**
     * @generated from protobuf field: optional string result_message = 4;
     */
    resultMessage?: string;
    /**
     * @generated from protobuf field: uint32 transfer_length = 5;
     */
    transferLength: number;
}

/**
 * @generated MessageType for protobuf message cr.FileTransferResponse
 */
export declare const FileTransferResponse: FileTransferResponse$Type;

/**
 * / Describes file transfer state machine
 *
 * @generated from protobuf enum cr.FileTransferState
 */
export declare enum FileTransferState {
    /**
     * /< FILE_TRANSFER_INVALID
     *
     * @generated from protobuf enum value: FILE_TRANSFER_INVALID = 0;
     */
    FILE_TRANSFER_INVALID = 0,
    /**
     * /< IDLE
     *
     * @generated from protobuf enum value: IDLE = 1;
     */
    IDLE = 1,
    /**
     * /< INIT
     *
     * @generated from protobuf enum value: INIT = 2;
     */
    INIT = 2,
    /**
     * /< DATA
     *
     * @generated from protobuf enum value: DATA = 3;
     */
    DATA = 3,
    /**
     * /< COMPLETE
     *
     * @generated from protobuf enum value: COMPLETE = 4;
     */
    COMPLETE = 4
}

declare class Float32ParameterInfo$Type extends MessageType<Float32ParameterInfo> {
    constructor();
    create(value?: PartialMessage<Float32ParameterInfo>): Float32ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Float32ParameterInfo): Float32ParameterInfo;
    internalBinaryWrite(message: Float32ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a float32
 *
 * @generated from protobuf message cr.Float32ParameterInfo
 */
export declare interface Float32ParameterInfo {
    /**
     * @generated from protobuf field: optional float range_min = 1;
     */
    rangeMin?: number;
    /**
     * @generated from protobuf field: optional float range_max = 2;
     */
    rangeMax?: number;
    /**
     * @generated from protobuf field: optional float default_value = 3;
     */
    defaultValue?: number;
    /**
     * @generated from protobuf field: optional uint32 precision = 4;
     */
    precision?: number;
    /**
     * @generated from protobuf field: optional string units = 5;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.Float32ParameterInfo
 */
export declare const Float32ParameterInfo: Float32ParameterInfo$Type;

declare class Float64ParameterInfo$Type extends MessageType<Float64ParameterInfo> {
    constructor();
    create(value?: PartialMessage<Float64ParameterInfo>): Float64ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Float64ParameterInfo): Float64ParameterInfo;
    internalBinaryWrite(message: Float64ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a float64
 *
 * @generated from protobuf message cr.Float64ParameterInfo
 */
export declare interface Float64ParameterInfo {
    /**
     * @generated from protobuf field: optional double range_min = 1;
     */
    rangeMin?: number;
    /**
     * @generated from protobuf field: optional double range_max = 2;
     */
    rangeMax?: number;
    /**
     * @generated from protobuf field: optional double default_value = 3;
     */
    defaultValue?: number;
    /**
     * @generated from protobuf field: optional uint32 precision = 4;
     */
    precision?: number;
    /**
     * @generated from protobuf field: optional string units = 5;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.Float64ParameterInfo
 */
export declare const Float64ParameterInfo: Float64ParameterInfo$Type;

declare class Int32ParameterInfo$Type extends MessageType<Int32ParameterInfo> {
    constructor();
    create(value?: PartialMessage<Int32ParameterInfo>): Int32ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int32ParameterInfo): Int32ParameterInfo;
    internalBinaryWrite(message: Int32ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes an sint32
 *
 * @generated from protobuf message cr.Int32ParameterInfo
 */
export declare interface Int32ParameterInfo {
    /**
     * @generated from protobuf field: optional int32 range_min = 1;
     */
    rangeMin?: number;
    /**
     * @generated from protobuf field: optional int32 range_max = 2;
     */
    rangeMax?: number;
    /**
     * @generated from protobuf field: optional int32 default_value = 3;
     */
    defaultValue?: number;
    /**
     * @generated from protobuf field: optional string units = 4;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.Int32ParameterInfo
 */
export declare const Int32ParameterInfo: Int32ParameterInfo$Type;

declare class Int64ParameterInfo$Type extends MessageType<Int64ParameterInfo> {
    constructor();
    create(value?: PartialMessage<Int64ParameterInfo>): Int64ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int64ParameterInfo): Int64ParameterInfo;
    internalBinaryWrite(message: Int64ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes an sint64
 *
 * @generated from protobuf message cr.Int64ParameterInfo
 */
export declare interface Int64ParameterInfo {
    /**
     * @generated from protobuf field: optional int64 range_min = 1;
     */
    rangeMin?: bigint;
    /**
     * @generated from protobuf field: optional int64 range_max = 2;
     */
    rangeMax?: bigint;
    /**
     * @generated from protobuf field: optional int64 default_value = 3;
     */
    defaultValue?: bigint;
    /**
     * @generated from protobuf field: optional string units = 4;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.Int64ParameterInfo
 */
export declare const Int64ParameterInfo: Int64ParameterInfo$Type;

export declare namespace MathUtil {
    export function getRandomUint(max?: number, min?: number): number;
}

export declare namespace MessageUtil {
    export function buildReachMessageHeader(messageType?: ReachMessageTypes, remainingObjects?: number, clientId?: number, endpointId?: number, transactionId?: number): ReachMessageHeader;
    export function buildAhsokaMessageHeader(header: ReachMessageHeader): AhsokaMessageHeader;
    export function buildReachMessageFromType(messageType: ReachMessageTypes, payload?: any, config?: Partial<{
        remainingObjects: number;
        clientId: number;
        endpointId: number;
        transactionId: number;
    }>): ReachMessage;
    export function buildReachMessage(header: ReachMessageHeader, payload?: any): ReachMessage;
    export function getParamValue(data: any, id?: number, type?: ParameterDataType, timestamp?: number): ParameterValue;
}

/**
 * A class for managing communications between a Reach Protocol device (server) and client.
 * @remarks This should be implemented appropriately for the data transport method being used, such as BLE.
 */
export declare abstract class NetworkAccess {
    protected onMessageSubject: Subject<Uint8Array>;
    /**
     * Observable fired whenever new raw data is received from the Reach Protocol device (server).
     */
    onMessage$: Observable<Uint8Array>;
    /**
     * Sends data to a Reach Protocol device (server).  This method should return upon successful transmission of the data.
     * @param bytes - The raw bytes to be sent, generally containing a Reach Protocol message
     */
    abstract sendBytes(bytes: Uint8Array): void | Promise<void | Uint8Array>;
    /**
     * Sends a provided Reach Protocol message to the device via the provided method for sending bytes.
     * @param message - The message to be sent to the device.
     * @param classicHeader - Whether the legacy "classic" header format should be used.  Defaults to false.
     * @returns The return from the {@link sendBytes} function call
     */
    send(message: ReachMessage, classicHeader?: boolean): void | Promise<void | Uint8Array>;
    /**
     * A method to be called whenever bytes are received from the Reach Protocol device (server).
     * These bytes are then parsed as a Reach Protocol message.
     * @param bytes - The raw bytes from the device
     */
    received(bytes: Uint8Array): void;
}

/**
 * / These are the types of data that can be stored as parameters.
 *
 * @generated from protobuf enum cr.ParameterDataType
 */
export declare enum ParameterDataType {
    /**
     * /< Unsigned 32 bit integer.
     *
     * @generated from protobuf enum value: UINT32 = 0;
     */
    UINT32 = 0,
    /**
     * /< Signed 32 bit integer.
     *
     * @generated from protobuf enum value: INT32 = 1;
     */
    INT32 = 1,
    /**
     * /< 32 bit floating point.
     *
     * @generated from protobuf enum value: FLOAT32 = 2;
     */
    FLOAT32 = 2,
    /**
     * /< Unsigned 64 bit integer.
     *
     * @generated from protobuf enum value: UINT64 = 3;
     */
    UINT64 = 3,
    /**
     * /< Signed 64 bit integer.
     *
     * @generated from protobuf enum value: INT64 = 4;
     */
    INT64 = 4,
    /**
     * /< 64 bit floating point.
     *
     * @generated from protobuf enum value: FLOAT64 = 5;
     */
    FLOAT64 = 5,
    /**
     * /< boolean (0 or 1)
     *
     * @generated from protobuf enum value: BOOL = 6;
     */
    BOOL = 6,
    /**
     * /< ASCII or UTF-8. Null Terminated.
     *
     * @generated from protobuf enum value: STRING = 7;
     */
    STRING = 7,
    /**
     * /< An extended description gives names to 32 bit integer values.
     *
     * @generated from protobuf enum value: ENUMERATION = 8;
     */
    ENUMERATION = 8,
    /**
     * /< An extended description gives names to up to 64 bit positions.
     *
     * @generated from protobuf enum value: BIT_FIELD = 9;
     */
    BIT_FIELD = 9,
    /**
     * /< An array of bytes.
     *
     * @generated from protobuf enum value: BYTE_ARRAY = 10;
     */
    BYTE_ARRAY = 10
}

declare class ParameterDisableNotifications$Type extends MessageType<ParameterDisableNotifications> {
    constructor();
    create(value?: PartialMessage<ParameterDisableNotifications>): ParameterDisableNotifications;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterDisableNotifications): ParameterDisableNotifications;
    internalBinaryWrite(message: ParameterDisableNotifications, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A message used to disable notifications
 *
 * @generated from protobuf message cr.ParameterDisableNotifications
 */
export declare interface ParameterDisableNotifications {
    /**
     * @generated from protobuf field: repeated uint32 parameter_ids = 1;
     */
    parameterIds: number[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterDisableNotifications
 */
export declare const ParameterDisableNotifications: ParameterDisableNotifications$Type;

declare class ParameterEnableNotifications$Type extends MessageType<ParameterEnableNotifications> {
    constructor();
    create(value?: PartialMessage<ParameterEnableNotifications>): ParameterEnableNotifications;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterEnableNotifications): ParameterEnableNotifications;
    internalBinaryWrite(message: ParameterEnableNotifications, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A message used to enable notifications
 *
 * @generated from protobuf message cr.ParameterEnableNotifications
 */
export declare interface ParameterEnableNotifications {
    /**
     * @generated from protobuf field: repeated cr.ParameterNotifyConfig configs = 1;
     */
    configs: ParameterNotifyConfig[];
    /**
     * @generated from protobuf field: bool disable_all_first = 2;
     */
    disableAllFirst: boolean;
}

/**
 * @generated MessageType for protobuf message cr.ParameterEnableNotifications
 */
export declare const ParameterEnableNotifications: ParameterEnableNotifications$Type;

/**
 * Organized format for interacting with extended info for enums, bools, and bitfields
 */
export declare class ParameterExtendedInfo {
    /**
     * The data type being referenced by this extended info.  Cross-type labels are discouraged (TODO).
     */
    dataType: ParameterDataType;
    /**
     * The names associated with values (enums, bools) or positions (bitfields) of a parameter.
     */
    names: Map<number, string>;
    constructor(info: ParamExInfoResponse);
    extendInfo(info: ParamExInfoResponse): void;
}

declare class ParameterInfo$Type extends MessageType<ParameterInfo> {
    constructor();
    create(value?: PartialMessage<ParameterInfo>): ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterInfo): ParameterInfo;
    internalBinaryWrite(message: ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A ParameterInfo structure describes a parameter so that it can be easily viewed an edited
 * / by humans using a generic parameter editor.
 *
 * @generated from protobuf message cr.ParameterInfo
 */
export declare interface ParameterInfo {
    /**
     * @generated from protobuf field: uint32 id = 1;
     */
    id: number;
    /**
     * @generated from protobuf field: string name = 2;
     */
    name: string;
    /**
     * @generated from protobuf field: optional string description = 3;
     */
    description?: string;
    /**
     * @generated from protobuf field: cr.AccessLevel access = 4;
     */
    access: AccessLevel;
    /**
     * @generated from protobuf field: cr.StorageLocation storage_location = 5;
     */
    storageLocation: StorageLocation;
    /**
     * @generated from protobuf oneof: desc
     */
    desc: {
        oneofKind: "uint32Desc";
        /**
         * @generated from protobuf field: cr.Uint32ParameterInfo uint32_desc = 6;
         */
        uint32Desc: Uint32ParameterInfo;
    } | {
        oneofKind: "int32Desc";
        /**
         * @generated from protobuf field: cr.Int32ParameterInfo int32_desc = 7;
         */
        int32Desc: Int32ParameterInfo;
    } | {
        oneofKind: "float32Desc";
        /**
         * @generated from protobuf field: cr.Float32ParameterInfo float32_desc = 8;
         */
        float32Desc: Float32ParameterInfo;
    } | {
        oneofKind: "uint64Desc";
        /**
         * @generated from protobuf field: cr.Uint64ParameterInfo uint64_desc = 9;
         */
        uint64Desc: Uint64ParameterInfo;
    } | {
        oneofKind: "int64Desc";
        /**
         * @generated from protobuf field: cr.Int64ParameterInfo int64_desc = 10;
         */
        int64Desc: Int64ParameterInfo;
    } | {
        oneofKind: "float64Desc";
        /**
         * @generated from protobuf field: cr.Float64ParameterInfo float64_desc = 11;
         */
        float64Desc: Float64ParameterInfo;
    } | {
        oneofKind: "boolDesc";
        /**
         * @generated from protobuf field: cr.BoolParameterInfo bool_desc = 12;
         */
        boolDesc: BoolParameterInfo;
    } | {
        oneofKind: "stringDesc";
        /**
         * @generated from protobuf field: cr.StringParameterInfo string_desc = 13;
         */
        stringDesc: StringParameterInfo;
    } | {
        oneofKind: "enumDesc";
        /**
         * @generated from protobuf field: cr.EnumParameterInfo enum_desc = 14;
         */
        enumDesc: EnumParameterInfo;
    } | {
        oneofKind: "bitfieldDesc";
        /**
         * @generated from protobuf field: cr.BitfieldParameterInfo bitfield_desc = 15;
         */
        bitfieldDesc: BitfieldParameterInfo;
    } | {
        oneofKind: "bytearrayDesc";
        /**
         * @generated from protobuf field: cr.ByteArrayParameterInfo bytearray_desc = 16;
         */
        bytearrayDesc: ByteArrayParameterInfo;
    } | {
        oneofKind: undefined;
    };
}

/**
 * @generated MessageType for protobuf message cr.ParameterInfo
 */
export declare const ParameterInfo: ParameterInfo$Type;

declare class ParameterInfoRequest$Type extends MessageType<ParameterInfoRequest> {
    constructor();
    create(value?: PartialMessage<ParameterInfoRequest>): ParameterInfoRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterInfoRequest): ParameterInfoRequest;
    internalBinaryWrite(message: ParameterInfoRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * /
 * / Parameter Service
 * / Parameters provide a simple key:value database. The key is an ID number.
 * / The value can be of various common types up to (typically) 32 bytes.
 * / Parameters support a robust description which can be const, stored in flash.
 * / Parameters can be configured to support notifying the client.
 * /
 * / The ParameterInfoRequest is used by the client to request detailed information
 * / about a set of parameters.
 *
 * @generated from protobuf message cr.ParameterInfoRequest
 */
export declare interface ParameterInfoRequest {
    /**
     * @generated from protobuf field: repeated uint32 parameter_ids = 2;
     */
    parameterIds: number[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterInfoRequest
 */
export declare const ParameterInfoRequest: ParameterInfoRequest$Type;

declare class ParameterInfoResponse$Type extends MessageType<ParameterInfoResponse> {
    constructor();
    create(value?: PartialMessage<ParameterInfoResponse>): ParameterInfoResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterInfoResponse): ParameterInfoResponse;
    internalBinaryWrite(message: ParameterInfoResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to ParameterInfoRequest
 *
 * @generated from protobuf message cr.ParameterInfoResponse
 */
export declare interface ParameterInfoResponse {
    /**
     * @generated from protobuf field: repeated cr.ParameterInfo parameter_infos = 1;
     */
    parameterInfos: ParameterInfo[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterInfoResponse
 */
export declare const ParameterInfoResponse: ParameterInfoResponse$Type;

declare class ParameterNotification$Type extends MessageType<ParameterNotification> {
    constructor();
    create(value?: PartialMessage<ParameterNotification>): ParameterNotification;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterNotification): ParameterNotification;
    internalBinaryWrite(message: ParameterNotification, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A message of this type is sent by the server when parameters change.
 *
 * @generated from protobuf message cr.ParameterNotification
 */
export declare interface ParameterNotification {
    /**
     * @generated from protobuf field: repeated cr.ParameterValue values = 2;
     */
    values: ParameterValue[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterNotification
 */
export declare const ParameterNotification: ParameterNotification$Type;

declare class ParameterNotifyConfig$Type extends MessageType<ParameterNotifyConfig> {
    constructor();
    create(value?: PartialMessage<ParameterNotifyConfig>): ParameterNotifyConfig;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterNotifyConfig): ParameterNotifyConfig;
    internalBinaryWrite(message: ParameterNotifyConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Parameter Notification configuration
 * / Notification can be enabled with conditions for each parameter.
 *
 * @generated from protobuf message cr.ParameterNotifyConfig
 */
export declare interface ParameterNotifyConfig {
    /**
     * @generated from protobuf field: uint32 parameter_id = 1;
     */
    parameterId: number;
    /**
     * @generated from protobuf field: uint32 minimum_notification_period = 2;
     */
    minimumNotificationPeriod: number;
    /**
     * @generated from protobuf field: uint32 maximum_notification_period = 3;
     */
    maximumNotificationPeriod: number;
    /**
     * @generated from protobuf field: float minimum_delta = 4;
     */
    minimumDelta: number;
}

/**
 * @generated MessageType for protobuf message cr.ParameterNotifyConfig
 */
export declare const ParameterNotifyConfig: ParameterNotifyConfig$Type;

declare class ParameterNotifyConfigResponse$Type extends MessageType<ParameterNotifyConfigResponse> {
    constructor();
    create(value?: PartialMessage<ParameterNotifyConfigResponse>): ParameterNotifyConfigResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterNotifyConfigResponse): ParameterNotifyConfigResponse;
    internalBinaryWrite(message: ParameterNotifyConfigResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to enable and disable notifications
 *
 * @generated from protobuf message cr.ParameterNotifyConfigResponse
 */
export declare interface ParameterNotifyConfigResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 2;
     */
    resultMessage?: string;
}

/**
 * @generated MessageType for protobuf message cr.ParameterNotifyConfigResponse
 */
export declare const ParameterNotifyConfigResponse: ParameterNotifyConfigResponse$Type;

declare class ParameterRead$Type extends MessageType<ParameterRead> {
    constructor();
    create(value?: PartialMessage<ParameterRead>): ParameterRead;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterRead): ParameterRead;
    internalBinaryWrite(message: ParameterRead, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure used to read one or more parameters
 *
 * @generated from protobuf message cr.ParameterRead
 */
export declare interface ParameterRead {
    /**
     * @generated from protobuf field: repeated uint32 parameter_ids = 2;
     */
    parameterIds: number[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterRead
 */
export declare const ParameterRead: ParameterRead$Type;

declare class ParameterReadResponse$Type extends MessageType<ParameterReadResponse> {
    constructor();
    create(value?: PartialMessage<ParameterReadResponse>): ParameterReadResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterReadResponse): ParameterReadResponse;
    internalBinaryWrite(message: ParameterReadResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure used to return the values read from one or more parameters
 *
 * @generated from protobuf message cr.ParameterReadResponse
 */
export declare interface ParameterReadResponse {
    /**
     * @generated from protobuf field: repeated cr.ParameterValue values = 3;
     */
    values: ParameterValue[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterReadResponse
 */
export declare const ParameterReadResponse: ParameterReadResponse$Type;

declare class ParameterValue$Type extends MessageType<ParameterValue> {
    constructor();
    create(value?: PartialMessage<ParameterValue>): ParameterValue;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterValue): ParameterValue;
    internalBinaryWrite(message: ParameterValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A message used to send or receive a single parameter value.
 *
 * @generated from protobuf message cr.ParameterValue
 */
export declare interface ParameterValue {
    /**
     * @generated from protobuf field: uint32 parameter_id = 1;
     */
    parameterId: number;
    /**
     * @generated from protobuf field: uint32 timestamp = 2;
     */
    timestamp: number;
    /**
     * @generated from protobuf oneof: value
     */
    value: {
        oneofKind: "uint32Value";
        /**
         * @generated from protobuf field: uint32 uint32_value = 3;
         */
        uint32Value: number;
    } | {
        oneofKind: "int32Value";
        /**
         * @generated from protobuf field: sint32 int32_value = 4;
         */
        int32Value: number;
    } | {
        oneofKind: "float32Value";
        /**
         * @generated from protobuf field: float float32_value = 5;
         */
        float32Value: number;
    } | {
        oneofKind: "uint64Value";
        /**
         * @generated from protobuf field: uint64 uint64_value = 6;
         */
        uint64Value: bigint;
    } | {
        oneofKind: "int64Value";
        /**
         * @generated from protobuf field: sint64 int64_value = 7;
         */
        int64Value: bigint;
    } | {
        oneofKind: "float64Value";
        /**
         * @generated from protobuf field: double float64_value = 8;
         */
        float64Value: number;
    } | {
        oneofKind: "boolValue";
        /**
         * @generated from protobuf field: bool bool_value = 9;
         */
        boolValue: boolean;
    } | {
        oneofKind: "stringValue";
        /**
         * @generated from protobuf field: string string_value = 10;
         */
        stringValue: string;
    } | {
        oneofKind: "enumValue";
        /**
         * @generated from protobuf field: uint32 enum_value = 11;
         */
        enumValue: number;
    } | {
        oneofKind: "bitfieldValue";
        /**
         * @generated from protobuf field: uint64 bitfield_value = 12;
         */
        bitfieldValue: bigint;
    } | {
        oneofKind: "bytesValue";
        /**
         * @generated from protobuf field: bytes bytes_value = 13;
         */
        bytesValue: Uint8Array;
    } | {
        oneofKind: undefined;
    };
}

/**
 * @generated MessageType for protobuf message cr.ParameterValue
 */
export declare const ParameterValue: ParameterValue$Type;

declare class ParameterWrite$Type extends MessageType<ParameterWrite> {
    constructor();
    create(value?: PartialMessage<ParameterWrite>): ParameterWrite;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterWrite): ParameterWrite;
    internalBinaryWrite(message: ParameterWrite, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure used to write one or more Parameters
 *
 * @generated from protobuf message cr.ParameterWrite
 */
export declare interface ParameterWrite {
    /**
     * @generated from protobuf field: repeated cr.ParameterValue values = 3;
     */
    values: ParameterValue[];
}

/**
 * @generated MessageType for protobuf message cr.ParameterWrite
 */
export declare const ParameterWrite: ParameterWrite$Type;

declare class ParameterWriteResponse$Type extends MessageType<ParameterWriteResponse> {
    constructor();
    create(value?: PartialMessage<ParameterWriteResponse>): ParameterWriteResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterWriteResponse): ParameterWriteResponse;
    internalBinaryWrite(message: ParameterWriteResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to a parameter write
 *
 * @generated from protobuf message cr.ParameterWriteResponse
 */
export declare interface ParameterWriteResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 2;
     */
    resultMessage?: string;
}

/**
 * @generated MessageType for protobuf message cr.ParameterWriteResponse
 */
export declare const ParameterWriteResponse: ParameterWriteResponse$Type;

declare class ParamExInfoResponse$Type extends MessageType<ParamExInfoResponse> {
    constructor();
    create(value?: PartialMessage<ParamExInfoResponse>): ParamExInfoResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParamExInfoResponse): ParamExInfoResponse;
    internalBinaryWrite(message: ParamExInfoResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Describes enum, bitfield, and boolean labels
 *
 * @generated from protobuf message cr.ParamExInfoResponse
 */
export declare interface ParamExInfoResponse {
    /**
     * @generated from protobuf field: cr.ParameterDataType data_type = 2;
     */
    dataType: ParameterDataType;
    /**
     * @generated from protobuf field: repeated cr.ParamExKey keys = 3;
     */
    keys: ParamExKey[];
    /**
     * @generated from protobuf field: uint32 pei_id = 4;
     */
    peiId: number;
}

/**
 * @generated MessageType for protobuf message cr.ParamExInfoResponse
 */
export declare const ParamExInfoResponse: ParamExInfoResponse$Type;

declare class ParamExKey$Type extends MessageType<ParamExKey> {
    constructor();
    create(value?: PartialMessage<ParamExKey>): ParamExKey;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParamExKey): ParamExKey;
    internalBinaryWrite(message: ParamExKey, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The ParamExKey is used to give names to enums, bitfields, and booleans.
 * / It is typically supplied in an array.
 * / More than one parameter can point to the same ParamExKey.
 *
 * @generated from protobuf message cr.ParamExKey
 */
export declare interface ParamExKey {
    /**
     * @generated from protobuf field: uint32 id = 1;
     */
    id: number;
    /**
     * @generated from protobuf field: string name = 2;
     */
    name: string;
}

/**
 * @generated MessageType for protobuf message cr.ParamExKey
 */
export declare const ParamExKey: ParamExKey$Type;

/**
 * A user-friendly model for configuring parameter notifications
 */
export declare interface ParamNotifSettings {
    /**
     * The ID of the parameter to be notified
     */
    parameterId: number;
    /**
     * The minimum interval allowed between notifications, irrespective of value changes.
     */
    minInterval?: number;
    /**
     * The maximum interval allowed between notifications, irrespective of value changes.
     */
    maxInterval?: number;
    /**
     * The change in value required for a notification to be generated.  In the case of strings, any change will be notified.
     */
    valueDelta?: number;
}

export declare class ParsedParameterInfo implements ParameterInfo {
    /**
     * The ID used to reference the parameter
     */
    id: number;
    /**
     * The human-readable name of the parameter
     */
    name: string;
    /**
     * A human-readable description of the parameter
     */
    description?: string;
    /**
     * The R/W access granted to the client
     */
    access: AccessLevel;
    /**
     * The memory location of the parameter
     */
    storageLocation: StorageLocation;
    /**
     * Type-specific description information
     */
    desc: {
        oneofKind: "uint32Desc";
        /**
         * @generated from protobuf field: cr.Uint32ParameterInfo uint32_desc = 6;
         */
        uint32Desc: Uint32ParameterInfo;
    } | {
        oneofKind: "int32Desc";
        /**
         * @generated from protobuf field: cr.Int32ParameterInfo int32_desc = 7;
         */
        int32Desc: Int32ParameterInfo;
    } | {
        oneofKind: "float32Desc";
        /**
         * @generated from protobuf field: cr.Float32ParameterInfo float32_desc = 8;
         */
        float32Desc: Float32ParameterInfo;
    } | {
        oneofKind: "uint64Desc";
        /**
         * @generated from protobuf field: cr.Uint64ParameterInfo uint64_desc = 9;
         */
        uint64Desc: Uint64ParameterInfo;
    } | {
        oneofKind: "int64Desc";
        /**
         * @generated from protobuf field: cr.Int64ParameterInfo int64_desc = 10;
         */
        int64Desc: Int64ParameterInfo;
    } | {
        oneofKind: "float64Desc";
        /**
         * @generated from protobuf field: cr.Float64ParameterInfo float64_desc = 11;
         */
        float64Desc: Float64ParameterInfo;
    } | {
        oneofKind: "boolDesc";
        /**
         * @generated from protobuf field: cr.BoolParameterInfo bool_desc = 12;
         */
        boolDesc: BoolParameterInfo;
    } | {
        oneofKind: "stringDesc";
        /**
         * @generated from protobuf field: cr.StringParameterInfo string_desc = 13;
         */
        stringDesc: StringParameterInfo;
    } | {
        oneofKind: "enumDesc";
        /**
         * @generated from protobuf field: cr.EnumParameterInfo enum_desc = 14;
         */
        enumDesc: EnumParameterInfo;
    } | {
        oneofKind: "bitfieldDesc";
        /**
         * @generated from protobuf field: cr.BitfieldParameterInfo bitfield_desc = 15;
         */
        bitfieldDesc: BitfieldParameterInfo;
    } | {
        oneofKind: "bytearrayDesc";
        /**
         * @generated from protobuf field: cr.ByteArrayParameterInfo bytearray_desc = 16;
         */
        bytearrayDesc: ByteArrayParameterInfo;
    };
    dataType: ParameterDataType;
    constructor(info: ParameterInfo);
}

declare class PingRequest$Type extends MessageType<PingRequest> {
    constructor();
    create(value?: PartialMessage<PingRequest>): PingRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PingRequest): PingRequest;
    internalBinaryWrite(message: PingRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Request Object used to Echo Data for testing the Device Communication
 *
 * @generated from protobuf message cr.PingRequest
 */
export declare interface PingRequest {
    /**
     * @generated from protobuf field: bytes echo_data = 1;
     */
    echoData: Uint8Array;
}

/**
 * @generated MessageType for protobuf message cr.PingRequest
 */
export declare const PingRequest: PingRequest$Type;

declare class PingResponse$Type extends MessageType<PingResponse> {
    constructor();
    create(value?: PartialMessage<PingResponse>): PingResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PingResponse): PingResponse;
    internalBinaryWrite(message: PingResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Response Object used to Echo Data for testing the Device Communication
 *
 * @generated from protobuf message cr.PingResponse
 */
export declare interface PingResponse {
    /**
     * @generated from protobuf field: bytes echo_data = 1;
     */
    echoData: Uint8Array;
    /**
     * @generated from protobuf field: int32 signal_strength = 2;
     */
    signalStrength: number;
}

/**
 * @generated MessageType for protobuf message cr.PingResponse
 */
export declare const PingResponse: PingResponse$Type;

export declare type ProtoVersion = {
    semver: true;
    version: {
        major: number;
        minor: number;
        patch: number;
        note?: string;
    };
} | {
    semver: false;
    version: string;
};

declare class ReachMessage$Type extends MessageType<ReachMessage> {
    constructor();
    create(value?: PartialMessage<ReachMessage>): ReachMessage;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ReachMessage): ReachMessage;
    internalBinaryWrite(message: ReachMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A reach packet includes a header and a payload.
 *
 * @generated from protobuf message cr.ReachMessage
 */
export declare interface ReachMessage {
    /**
     * @generated from protobuf field: cr.ReachMessageHeader header = 1;
     */
    header?: ReachMessageHeader;
    /**
     * @generated from protobuf field: bytes payload = 2;
     */
    payload: Uint8Array;
}

/**
 * @generated MessageType for protobuf message cr.ReachMessage
 */
export declare const ReachMessage: ReachMessage$Type;

declare class ReachMessageHeader$Type extends MessageType<ReachMessageHeader> {
    constructor();
    create(value?: PartialMessage<ReachMessageHeader>): ReachMessageHeader;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ReachMessageHeader): ReachMessageHeader;
    internalBinaryWrite(message: ReachMessageHeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / This is the "classic" Reach service routing message header.
 * / It is now deprecated in favor of the AhsokaMessageHeader.
 *
 * @generated from protobuf message cr.ReachMessageHeader
 */
export declare interface ReachMessageHeader {
    /**
     * @generated from protobuf field: uint32 message_type = 1;
     */
    messageType: number;
    /**
     * @generated from protobuf field: uint32 endpoint_id = 2;
     */
    endpointId: number;
    /**
     * @generated from protobuf field: uint32 client_id = 3;
     */
    clientId: number;
    /**
     * @generated from protobuf field: uint32 remaining_objects = 4;
     */
    remainingObjects: number;
    /**
     * @generated from protobuf field: uint32 transaction_id = 5;
     */
    transactionId: number;
}

/**
 * @generated MessageType for protobuf message cr.ReachMessageHeader
 */
export declare const ReachMessageHeader: ReachMessageHeader$Type;

/**
 * / These values identify the type of the Reach message.
 *
 * @generated from protobuf enum cr.ReachMessageTypes
 */
export declare enum ReachMessageTypes {
    /**
     * /< No Valid Message
     *
     * @generated from protobuf enum value: INVALID = 0;
     */
    INVALID = 0,
    /**
     * /< Inform client of an error condition
     *
     * @generated from protobuf enum value: ERROR_REPORT = 1;
     */
    ERROR_REPORT = 1,
    /**
     * /< Test the link to the server
     *
     * @generated from protobuf enum value: PING = 2;
     */
    PING = 2,
    /**
     * /< Open the communication with a server
     *
     * @generated from protobuf enum value: GET_DEVICE_INFO = 3;
     */
    GET_DEVICE_INFO = 3,
    /**
     * / Parameters
     *
     * /< Get a list of all of the parameters in the repository
     *
     * @generated from protobuf enum value: DISCOVER_PARAMETERS = 5;
     */
    DISCOVER_PARAMETERS = 5,
    /**
     * /< An extension to discover used by verbose parameters
     *
     * @generated from protobuf enum value: DISCOVER_PARAM_EX = 6;
     */
    DISCOVER_PARAM_EX = 6,
    /**
     * /< Get the values of a set of parameters
     *
     * @generated from protobuf enum value: READ_PARAMETERS = 7;
     */
    READ_PARAMETERS = 7,
    /**
     * /< Change the values of a set of parameters
     *
     * @generated from protobuf enum value: WRITE_PARAMETERS = 8;
     */
    WRITE_PARAMETERS = 8,
    /**
     * /< Sent from the server to the client when a parameter has changed
     *
     * @generated from protobuf enum value: PARAMETER_NOTIFICATION = 10;
     */
    PARAMETER_NOTIFICATION = 10,
    /**
     * /< Find out how notifications are setup
     *
     * @generated from protobuf enum value: DISCOVER_NOTIFICATIONS = 11;
     */
    DISCOVER_NOTIFICATIONS = 11,
    /**
     * /< setup parameter notifications
     *
     * @generated from protobuf enum value: PARAM_ENABLE_NOTIFY = 50;
     */
    PARAM_ENABLE_NOTIFY = 50,
    /**
     * /< disable parameter notifications
     *
     * @generated from protobuf enum value: PARAM_DISABLE_NOTIFY = 51;
     */
    PARAM_DISABLE_NOTIFY = 51,
    /**
     * / File Transfers
     *
     * /< Get a list of supported files
     *
     * @generated from protobuf enum value: DISCOVER_FILES = 12;
     */
    DISCOVER_FILES = 12,
    /**
     * /< Begin a file transfer
     *
     * @generated from protobuf enum value: TRANSFER_INIT = 13;
     */
    TRANSFER_INIT = 13,
    /**
     * /< (bi-directional) sends the requested data
     *
     * @generated from protobuf enum value: TRANSFER_DATA = 14;
     */
    TRANSFER_DATA = 14,
    /**
     * /< (bi-directional) Clears Sender to Send More Data
     *
     * @generated from protobuf enum value: TRANSFER_DATA_NOTIFICATION = 15;
     */
    TRANSFER_DATA_NOTIFICATION = 15,
    /**
     * /< Set file size to zero.
     *
     * @generated from protobuf enum value: ERASE_FILE = 16;
     */
    ERASE_FILE = 16,
    /**
     * / Commands
     *
     * /< Get a list of supported commands
     *
     * @generated from protobuf enum value: DISCOVER_COMMANDS = 17;
     */
    DISCOVER_COMMANDS = 17,
    /**
     * /< Reqeuest excecution of a command
     *
     * @generated from protobuf enum value: SEND_COMMAND = 18;
     */
    SEND_COMMAND = 18,
    /**
     * Command Line Interface
     *
     * /< Inform the other side (bi-directional) of a command line.
     *
     * @generated from protobuf enum value: CLI_NOTIFICATION = 20;
     */
    CLI_NOTIFICATION = 20,
    /**
     * Streams
     *
     * /< Get a list of supported streams
     *
     * @generated from protobuf enum value: DISCOVER_STREAMS = 25;
     */
    DISCOVER_STREAMS = 25,
    /**
     * /< Open a stream
     *
     * @generated from protobuf enum value: OPEN_STREAM = 26;
     */
    OPEN_STREAM = 26,
    /**
     * /< Close a stream
     *
     * @generated from protobuf enum value: CLOSE_STREAM = 27;
     */
    CLOSE_STREAM = 27,
    /**
     * /< Inform the other side (bi-directional) of data on a stream.
     *
     * @generated from protobuf enum value: STREAM_DATA_NOTIFICATION = 28;
     */
    STREAM_DATA_NOTIFICATION = 28,
    /**
     * Time
     *
     * /< Set the real time clock
     *
     * @generated from protobuf enum value: SET_TIME = 30;
     */
    SET_TIME = 30,
    /**
     * /< Read the real time clock
     *
     * @generated from protobuf enum value: GET_TIME = 31;
     */
    GET_TIME = 31,
    /**
     * WiFi
     *
     * /< Get a list of WiFi acces points
     *
     * @generated from protobuf enum value: DISCOVER_WIFI = 40;
     */
    DISCOVER_WIFI = 40,
    /**
     * /< Connect or disconnect to an access point
     *
     * @generated from protobuf enum value: WIFI_CONNECT = 41;
     */
    WIFI_CONNECT = 41
}

/**
 * / The major version generally changes to signal a break in compatibility
 *
 * @generated from protobuf enum cr.ReachProto_MAJOR_Version
 */
export declare enum ReachProto_MAJOR_Version {
    /**
     * MAJOR_V0       = 0;   // Must have a zero
     *
     * @generated from protobuf enum value: MAJOR_VERSION = 0;
     */
    MAJOR_VERSION = 0
}

/**
 * / The minor version changes at a release which is not completely compatible
 *
 * @generated from protobuf enum cr.ReachProto_MINOR_Version
 */
export declare enum ReachProto_MINOR_Version {
    /**
     * /< Must have a zero
     *
     * @generated from protobuf enum value: MINOR_V0 = 0;
     */
    MINOR_V0 = 0,
    /**
     * /< Update at a release or a big change
     *
     * @generated from protobuf enum value: MINOR_VERSION = 2;
     */
    MINOR_VERSION = 2
}

/**
 * / The patch version changes every time a hex file goes out the door.
 *
 * @generated from protobuf enum cr.ReachProto_PATCH_Version
 */
export declare enum ReachProto_PATCH_Version {
    /**
     * /< Must have a zero
     *
     * @generated from protobuf enum value: PATCH_V0 = 0;
     */
    PATCH_V0 = 0,
    /**
     * /< Update when something changes
     *
     * @generated from protobuf enum value: PATCH_VERSION = 3;
     */
    PATCH_VERSION = 3
}

declare class Request_2<T> {
    protected timeout: number;
    protected onMessage: (message: ReachMessage) => T;
    associatedTypes: ReachMessageTypes[];
    ids: RequestID;
    stateless?: boolean | undefined;
    protected timer: NodeJS.Timeout | undefined;
    protected timeoutHandler: () => void;
    protected deferred: CompletablePromise<T>;
    protected _state: T | undefined;
    get state(): T | undefined;
    /**
     * Creates a Request with handling for a no-response timeout, associated message types, and optional internal state
     * @param timeout
     * The interval between messages before a request is considered timed out, in ms. This timer must be started with resetTimeout().
     * @param onMessage
     * A function handling relevant incoming messages, returning an updated state if stateful
     * @param associatedTypes
     * The types of messages associated with this request and handled by onMessage. Error reports should generally not be included in this.
     * @param ids
     * The unique set of IDs accociated with a request
     * @param stateless
     * Whether the request is stateless. If set, wait() will return successfully even if no state has been set.
     */
    constructor(timeout: number, onMessage: (message: ReachMessage) => T, associatedTypes: ReachMessageTypes[], ids: RequestID, stateless?: boolean | undefined);
    wait(): Promise<T>;
    receivedMessage(response: ReachMessage): void;
    resetTimeout(): void;
    complete(): void;
    fail(error: Error): void;
    protected onTimeout(): void;
}
export { Request_2 as Request }

/**
 * User-facing configuration used when creating and sending a Request
 */
export declare interface RequestConfig {
    /**
     * The time (in ms) without receiving a new response after which a request will be treated as failed
     */
    timeout: number;
    /**
     * The ID of the client making a request to the server
     */
    clientId: number;
    /**
     * The ID of the endpoint within a server being communicated with
     */
    endpointId: number;
    /**
     * The ID of the transaction being conducted.  This should generally be generated internally.
     * This should be unique independent of client ID and endpoint ID where possible, but only must be unique within its client-endpoint configuration
     */
    transactionId: number;
}

/**
 * A set of IDs that uniquely identify a request's transaction
 */
export declare class RequestID {
    /**
     * The ID of the client making a request to the server
     */
    clientId: number;
    /**
     * The ID of the endpoint within a server being communicated with
     */
    endpointId: number;
    /**
     * The ID of the transaction being conducted.
     * This should be unique independent of client ID and endpoint ID where possible, but only must be unique within its client-endpoint configuration
     */
    transactionId: number;
    constructor(
    /**
     * The ID of the client making a request to the server
     */
    clientId: number, 
    /**
     * The ID of the endpoint within a server being communicated with
     */
    endpointId: number, 
    /**
     * The ID of the transaction being conducted.
     * This should be unique independent of client ID and endpoint ID where possible, but only must be unique within its client-endpoint configuration
     */
    transactionId: number);
    /**
     * A formatted string of the three IDs, suitable for use as a key in a hashmap.
     */
    get key(): string;
}

/**
 * Low-level configuration used when creating and sending a Request
 */
export declare interface RequestMechanics {
    /**
     * A list of message types that may come in as valid responses to a request.
     */
    expectedResponseTypes: ReachMessageTypes[];
    /**
     * Whether the request's result is a pure success/fail
     */
    stateless: boolean;
}

/**
 * A model for a single message sent by a client within a transaction
 */
export declare interface RequestMessage {
    /**
     * The payload of the message
     */
    payload: any;
    /**
     * The number of objects remaining in a chain of request messages within a transaction
     */
    remainingObjects?: number;
}

declare class SendCommand$Type extends MessageType<SendCommand> {
    constructor();
    create(value?: PartialMessage<SendCommand>): SendCommand;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SendCommand): SendCommand;
    internalBinaryWrite(message: SendCommand, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Prompts the device to execute this command.
 *
 * @generated from protobuf message cr.SendCommand
 */
export declare interface SendCommand {
    /**
     * @generated from protobuf field: uint32 command_id = 1;
     */
    commandId: number;
}

/**
 * @generated MessageType for protobuf message cr.SendCommand
 */
export declare const SendCommand: SendCommand$Type;

declare class SendCommandResponse$Type extends MessageType<SendCommandResponse> {
    constructor();
    create(value?: PartialMessage<SendCommandResponse>): SendCommandResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SendCommandResponse): SendCommandResponse;
    internalBinaryWrite(message: SendCommandResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A response acknowledging the completion of a command.
 *
 * @generated from protobuf message cr.SendCommandResponse
 */
export declare interface SendCommandResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 2;
     */
    resultMessage?: string;
}

/**
 * @generated MessageType for protobuf message cr.SendCommandResponse
 */
export declare const SendCommandResponse: SendCommandResponse$Type;

/**
 * / binary bit masks or'ed together into the DeviceInfoResponse.services
 *
 * @generated from protobuf enum cr.ServiceIds
 */
export declare enum ServiceIds {
    /**
     * /< No services.  Device info service is required.
     *
     * @generated from protobuf enum value: NO_SVC_ID = 0;
     */
    NO_SVC_ID = 0,
    /**
     * /< Set this bit when the device supports the parameter service
     *
     * @generated from protobuf enum value: PARAMETER_REPO = 1;
     */
    PARAMETER_REPO = 1,
    /**
     * /< Set this bit when the device supports the file service
     *
     * @generated from protobuf enum value: FILES = 2;
     */
    FILES = 2,
    /**
     * /< Set this bit when the device supports the stream service
     *
     * @generated from protobuf enum value: STREAMS = 4;
     */
    STREAMS = 4,
    /**
     * /< Set this bit when the device supports the command service
     *
     * @generated from protobuf enum value: COMMANDS = 8;
     */
    COMMANDS = 8,
    /**
     * /< Set this bit when the device supports the command line interface
     *
     * @generated from protobuf enum value: CLI = 16;
     */
    CLI = 16,
    /**
     * /< Set this bit when the device supports the time service
     *
     * @generated from protobuf enum value: TIME = 32;
     */
    TIME = 32,
    /**
     * /< Set this bit when the device supports the WiFi service
     *
     * @generated from protobuf enum value: WIFI = 64;
     */
    WIFI = 64
}

/**
 * / This describes the offset of each member of the BufferSizes message when packed for transmission
 *
 * @generated from protobuf enum cr.SizesOffsets
 */
export declare enum SizesOffsets {
    /**
     * /< uint16_t, little endian
     *
     * @generated from protobuf enum value: MAX_MESSAGE_SIZE_OFFSET = 0;
     */
    MAX_MESSAGE_SIZE_OFFSET = 0,
    /**
     * /< uint16_t, little endian
     *
     * @generated from protobuf enum value: BIG_DATA_BUFFER_SIZE_OFFSET = 2;
     */
    BIG_DATA_BUFFER_SIZE_OFFSET = 2,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: PARAMETER_BUFFER_COUNT_OFFSET = 4;
     */
    PARAMETER_BUFFER_COUNT_OFFSET = 4,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: NUM_PARAMS_IN_RESPONSE_OFFSET = 5;
     */
    NUM_PARAMS_IN_RESPONSE_OFFSET = 5,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: DESCRIPTION_LEN_OFFSET = 6;
     */
    DESCRIPTION_LEN_OFFSET = 6,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: MAX_PARAM_BYTES_OFFSET = 7;
     */
    MAX_PARAM_BYTES_OFFSET = 7,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: PARAM_INFO_DESCRIPTION_LEN_OFFSET = 8;
     */
    PARAM_INFO_DESCRIPTION_LEN_OFFSET = 8,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: MEDIUM_STRING_LEN_OFFSET = 9;
     */
    MEDIUM_STRING_LEN_OFFSET = 9,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: SHORT_STRING_LEN_OFFSET = 10;
     */
    SHORT_STRING_LEN_OFFSET = 10,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: PARAM_NOTIFY_CONFIG_COUNT_OFFSET = 11;
     */
    PARAM_NOTIFY_CONFIG_COUNT_OFFSET = 11,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: NUM_DESCRIPTORS_IN_RESPONSE_OFFSET = 12;
     */
    NUM_DESCRIPTORS_IN_RESPONSE_OFFSET = 12,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: NUM_PARAM_NOTIFICATIONS_OFFSET = 13;
     */
    NUM_PARAM_NOTIFICATIONS_OFFSET = 13,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: NUM_COMMANDS_IN_RESPONSE_OFFSET = 14;
     */
    NUM_COMMANDS_IN_RESPONSE_OFFSET = 14,
    /**
     * /< uint8_t
     *
     * @generated from protobuf enum value: COUNT_PARAM_DESC_IN_RESPONSE_OFFSET = 15;
     */
    COUNT_PARAM_DESC_IN_RESPONSE_OFFSET = 15,
    /**
     * /< just the size
     *
     * @generated from protobuf enum value: STRUCTURE_SIZE = 16;
     */
    STRUCTURE_SIZE = 16
}

/**
 * / The types of memory in which parameters are stored.  RAM and NVM (Non Volatile Memory) are most common.
 *
 * @generated from protobuf enum cr.StorageLocation
 */
export declare enum StorageLocation {
    /**
     * /< unknown, not used
     *
     * @generated from protobuf enum value: STORAGE_LOCATION_INVALID = 0;
     */
    STORAGE_LOCATION_INVALID = 0,
    /**
     * /< RAM, volatile, not saved on reboot.
     *
     * @generated from protobuf enum value: RAM = 1;
     */
    RAM = 1,
    /**
     * /< Flash or some other method saved over reboot
     *
     * @generated from protobuf enum value: NONVOLATILE = 2;
     */
    NONVOLATILE = 2,
    /**
     * /< In case a device has two RAM locations
     *
     * @generated from protobuf enum value: RAM_EXTENDED = 3;
     */
    RAM_EXTENDED = 3,
    /**
     * /< In case a device has two non volatile locations
     *
     * @generated from protobuf enum value: NONVOLATILE_EXTENDED = 4;
     */
    NONVOLATILE_EXTENDED = 4
}

declare class StreamClose$Type extends MessageType<StreamClose> {
    constructor();
    create(value?: PartialMessage<StreamClose>): StreamClose;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamClose): StreamClose;
    internalBinaryWrite(message: StreamClose, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure requesting to close a stream
 *
 * @generated from protobuf message cr.StreamClose
 */
export declare interface StreamClose {
    /**
     * @generated from protobuf field: uint32 stream_id = 1;
     */
    streamId: number;
}

/**
 * @generated MessageType for protobuf message cr.StreamClose
 */
export declare const StreamClose: StreamClose$Type;

declare class StreamData$Type extends MessageType<StreamData> {
    constructor();
    create(value?: PartialMessage<StreamData>): StreamData;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamData): StreamData;
    internalBinaryWrite(message: StreamData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Bi-Directional message used to asynchronously send stream data to the other side.
 *
 * @generated from protobuf message cr.StreamData
 */
export declare interface StreamData {
    /**
     * @generated from protobuf field: uint32 stream_id = 1;
     */
    streamId: number;
    /**
     * @generated from protobuf field: uint32 roll_count = 2;
     */
    rollCount: number;
    /**
     * @generated from protobuf field: bytes message_data = 3;
     */
    messageData: Uint8Array;
    /**
     * @generated from protobuf field: optional int32 checksum = 4;
     */
    checksum?: number;
}

/**
 * @generated MessageType for protobuf message cr.StreamData
 */
export declare const StreamData: StreamData$Type;

declare class StreamInfo$Type extends MessageType<StreamInfo> {
    constructor();
    create(value?: PartialMessage<StreamInfo>): StreamInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamInfo): StreamInfo;
    internalBinaryWrite(message: StreamInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure describing a stream
 *
 * @generated from protobuf message cr.StreamInfo
 */
export declare interface StreamInfo {
    /**
     * @generated from protobuf field: uint32 stream_id = 1;
     */
    streamId: number;
    /**
     * @generated from protobuf field: cr.AccessLevel access = 2;
     */
    access: AccessLevel;
    /**
     * @generated from protobuf field: string name = 3;
     */
    name: string;
    /**
     * @generated from protobuf field: string description = 4;
     */
    description: string;
}

/**
 * @generated MessageType for protobuf message cr.StreamInfo
 */
export declare const StreamInfo: StreamInfo$Type;

declare class StreamOpen$Type extends MessageType<StreamOpen> {
    constructor();
    create(value?: PartialMessage<StreamOpen>): StreamOpen;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamOpen): StreamOpen;
    internalBinaryWrite(message: StreamOpen, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure requesting to open a stream
 *
 * @generated from protobuf message cr.StreamOpen
 */
export declare interface StreamOpen {
    /**
     * @generated from protobuf field: uint32 stream_id = 1;
     */
    streamId: number;
}

/**
 * @generated MessageType for protobuf message cr.StreamOpen
 */
export declare const StreamOpen: StreamOpen$Type;

declare class StreamResponse$Type extends MessageType<StreamResponse> {
    constructor();
    create(value?: PartialMessage<StreamResponse>): StreamResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamResponse): StreamResponse;
    internalBinaryWrite(message: StreamResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to StreamOpen and StreamClose requests
 *
 * @generated from protobuf message cr.StreamResponse
 */
export declare interface StreamResponse {
    /**
     * @generated from protobuf field: uint32 stream_id = 1;
     */
    streamId: number;
    /**
     * @generated from protobuf field: int32 result = 2;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 3;
     */
    resultMessage?: string;
}

/**
 * @generated MessageType for protobuf message cr.StreamResponse
 */
export declare const StreamResponse: StreamResponse$Type;

declare class StringParameterInfo$Type extends MessageType<StringParameterInfo> {
    constructor();
    create(value?: PartialMessage<StringParameterInfo>): StringParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StringParameterInfo): StringParameterInfo;
    internalBinaryWrite(message: StringParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a string
 *
 * @generated from protobuf message cr.StringParameterInfo
 */
export declare interface StringParameterInfo {
    /**
     * @generated from protobuf field: optional string default_value = 1;
     */
    defaultValue?: string;
    /**
     * @generated from protobuf field: uint32 max_size = 2;
     */
    maxSize: number;
}

/**
 * @generated MessageType for protobuf message cr.StringParameterInfo
 */
export declare const StringParameterInfo: StringParameterInfo$Type;

export declare namespace StringUtil {
    export function encodeStringToUint8Array(str: string): Uint8Array;
    export function decodeStringFromUint8Array(bytes: Uint8Array): string;
    export function removeAnsiColorCodes(text: string): string;
}

declare class TimeGetRequest$Type extends MessageType<TimeGetRequest> {
    constructor();
    create(value?: PartialMessage<TimeGetRequest>): TimeGetRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TimeGetRequest): TimeGetRequest;
    internalBinaryWrite(message: TimeGetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A request to read the time from the server.
 *
 * @generated from protobuf message cr.TimeGetRequest
 */
export declare interface TimeGetRequest {
}

/**
 * @generated MessageType for protobuf message cr.TimeGetRequest
 */
export declare const TimeGetRequest: TimeGetRequest$Type;

declare class TimeGetResponse$Type extends MessageType<TimeGetResponse> {
    constructor();
    create(value?: PartialMessage<TimeGetResponse>): TimeGetResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TimeGetResponse): TimeGetResponse;
    internalBinaryWrite(message: TimeGetResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to a TimeGetRequest
 *
 * @generated from protobuf message cr.TimeGetResponse
 */
export declare interface TimeGetResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 2;
     */
    resultMessage?: string;
    /**
     * @generated from protobuf field: int64 seconds_utc = 3;
     */
    secondsUtc: bigint;
    /**
     * @generated from protobuf field: optional int32 timezone = 4;
     */
    timezone?: number;
}

/**
 * @generated MessageType for protobuf message cr.TimeGetResponse
 */
export declare const TimeGetResponse: TimeGetResponse$Type;

declare class TimeSetRequest$Type extends MessageType<TimeSetRequest> {
    constructor();
    create(value?: PartialMessage<TimeSetRequest>): TimeSetRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TimeSetRequest): TimeSetRequest;
    internalBinaryWrite(message: TimeSetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The optional Time Service is designed to allow the client to
 * / set and adjust the real time clock in a server device.
 * / The time is best specified as UTC plus timezone offset.
 * / Although the timezone is optional, it's best to use it.
 * / TimeSetRequest requests setting the server device time to this value.
 *
 * @generated from protobuf message cr.TimeSetRequest
 */
export declare interface TimeSetRequest {
    /**
     * @generated from protobuf field: int64 seconds_utc = 1;
     */
    secondsUtc: bigint;
    /**
     * @generated from protobuf field: optional int32 timezone = 2;
     */
    timezone?: number;
}

/**
 * @generated MessageType for protobuf message cr.TimeSetRequest
 */
export declare const TimeSetRequest: TimeSetRequest$Type;

declare class TimeSetResponse$Type extends MessageType<TimeSetResponse> {
    constructor();
    create(value?: PartialMessage<TimeSetResponse>): TimeSetResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TimeSetResponse): TimeSetResponse;
    internalBinaryWrite(message: TimeSetResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / The response to the TimeSetRequest
 *
 * @generated from protobuf message cr.TimeSetResponse
 */
export declare interface TimeSetResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: optional string result_message = 2;
     */
    resultMessage?: string;
}

/**
 * @generated MessageType for protobuf message cr.TimeSetResponse
 */
export declare const TimeSetResponse: TimeSetResponse$Type;

declare class Uint32ParameterInfo$Type extends MessageType<Uint32ParameterInfo> {
    constructor();
    create(value?: PartialMessage<Uint32ParameterInfo>): Uint32ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Uint32ParameterInfo): Uint32ParameterInfo;
    internalBinaryWrite(message: Uint32ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a uint32
 *
 * @generated from protobuf message cr.Uint32ParameterInfo
 */
export declare interface Uint32ParameterInfo {
    /**
     * @generated from protobuf field: optional uint32 range_min = 1;
     */
    rangeMin?: number;
    /**
     * @generated from protobuf field: optional uint32 range_max = 2;
     */
    rangeMax?: number;
    /**
     * @generated from protobuf field: optional uint32 default_value = 3;
     */
    defaultValue?: number;
    /**
     * @generated from protobuf field: optional string units = 4;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.Uint32ParameterInfo
 */
export declare const Uint32ParameterInfo: Uint32ParameterInfo$Type;

declare class Uint64ParameterInfo$Type extends MessageType<Uint64ParameterInfo> {
    constructor();
    create(value?: PartialMessage<Uint64ParameterInfo>): Uint64ParameterInfo;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Uint64ParameterInfo): Uint64ParameterInfo;
    internalBinaryWrite(message: Uint64ParameterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A member of a union (oneof) that describes a uint64
 *
 * @generated from protobuf message cr.Uint64ParameterInfo
 */
export declare interface Uint64ParameterInfo {
    /**
     * @generated from protobuf field: optional uint64 range_min = 1;
     */
    rangeMin?: bigint;
    /**
     * @generated from protobuf field: optional uint64 range_max = 2;
     */
    rangeMax?: bigint;
    /**
     * @generated from protobuf field: optional uint64 default_value = 3;
     */
    defaultValue?: bigint;
    /**
     * @generated from protobuf field: optional string units = 4;
     */
    units?: string;
}

/**
 * @generated MessageType for protobuf message cr.Uint64ParameterInfo
 */
export declare const Uint64ParameterInfo: Uint64ParameterInfo$Type;

/**
 * / WiFi Band
 *
 * @generated from protobuf enum cr.WiFiBand
 */
export declare enum WiFiBand {
    /**
     * /< Not specified
     *
     * @generated from protobuf enum value: NO_BAND = 0;
     */
    NO_BAND = 0,
    /**
     * /< 2.4GHz
     *
     * @generated from protobuf enum value: BAND_2 = 2;
     */
    BAND_2 = 2,
    /**
     * /< 5GHz
     *
     * @generated from protobuf enum value: BAND_5 = 5;
     */
    BAND_5 = 5
}

declare class WiFiConnectionRequest$Type extends MessageType<WiFiConnectionRequest> {
    constructor();
    create(value?: PartialMessage<WiFiConnectionRequest>): WiFiConnectionRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WiFiConnectionRequest): WiFiConnectionRequest;
    internalBinaryWrite(message: WiFiConnectionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / A structure describing a WiFi connection request
 *
 * @generated from protobuf message cr.WiFiConnectionRequest
 */
export declare interface WiFiConnectionRequest {
    /**
     * @generated from protobuf field: string ssid = 1;
     */
    ssid: string;
    /**
     * @generated from protobuf field: bool connect = 2;
     */
    connect: boolean;
    /**
     * @generated from protobuf field: bool disconnect = 3;
     */
    disconnect: boolean;
    /**
     * @generated from protobuf field: optional string password = 4;
     */
    password?: string;
    /**
     * @generated from protobuf field: optional bool autoconnect = 5;
     */
    autoconnect?: boolean;
}

/**
 * @generated MessageType for protobuf message cr.WiFiConnectionRequest
 */
export declare const WiFiConnectionRequest: WiFiConnectionRequest$Type;

declare class WiFiConnectionResponse$Type extends MessageType<WiFiConnectionResponse> {
    constructor();
    create(value?: PartialMessage<WiFiConnectionResponse>): WiFiConnectionResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WiFiConnectionResponse): WiFiConnectionResponse;
    internalBinaryWrite(message: WiFiConnectionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}

/**
 * / Describes the response to a WiFi connection request
 *
 * @generated from protobuf message cr.WiFiConnectionResponse
 */
export declare interface WiFiConnectionResponse {
    /**
     * @generated from protobuf field: int32 result = 1;
     */
    result: number;
    /**
     * @generated from protobuf field: bool connected = 2;
     */
    connected: boolean;
    /**
     * @generated from protobuf field: optional string result_message = 3;
     */
    resultMessage?: string;
    /**
     * @generated from protobuf field: optional int32 signal_strength = 4;
     */
    signalStrength?: number;
}

/**
 * @generated MessageType for protobuf message cr.WiFiConnectionResponse
 */
export declare const WiFiConnectionResponse: WiFiConnectionResponse$Type;

/**
 * / WiFi security type
 *
 * @generated from protobuf enum cr.WiFiSecurity
 */
export declare enum WiFiSecurity {
    /**
     * /< No security
     *
     * @generated from protobuf enum value: OPEN = 0;
     */
    OPEN = 0,
    /**
     * /< WEP
     *
     * @generated from protobuf enum value: WEP = 1;
     */
    WEP = 1,
    /**
     * /< WPA
     *
     * @generated from protobuf enum value: WPA = 2;
     */
    WPA = 2,
    /**
     * /< WPA2
     *
     * @generated from protobuf enum value: WPA2 = 3;
     */
    WPA2 = 3,
    /**
     * /< WPA3
     *
     * @generated from protobuf enum value: WPA3 = 4;
     */
    WPA3 = 4
}

export { }