@aircast-4g/mavlink/dist/dialects/test/index.d.ts

TypeScript type generator for MAVLink dialects

interface ParsedMAVLinkMessage$1 {
    timestamp: number;
    system_id: number;
    component_id: number;
    message_id: number;
    message_name: string;
    sequence: number;
    payload: Record<string, unknown>;
    protocol_version: 1 | 2;
    checksum: number;
    crc_ok: boolean;
    signature?: Uint8Array;
    dialect?: string;
}

interface MessageTestTypes {
    u64_array: number[];
    s64_array: number[];
    d_array: number[];
    u32_array: number[];
    s32_array: number[];
    f_array: number[];
    s: string;
    u64: number;
    s64: number;
    d: number;
    u16_array: number[];
    s16_array: number[];
    u32: number;
    s32: number;
    f: number;
    u8_array: number[];
    s8_array: number[];
    u16: number;
    s16: number;
    c: string;
    u8: number;
    s8: number;
}
interface MessageTypeMap {
    TEST_TYPES: MessageTestTypes;
}
type AnyMessage = ParsedMAVLinkMessage$1;
declare function isTestTypes(msg: ParsedMAVLinkMessage$1): msg is ParsedMAVLinkMessage$1 & {
    payload: MessageTestTypes;
};

interface ParsedMAVLinkMessage {
    timestamp: number;
    system_id: number;
    component_id: number;
    message_id: number;
    message_name: string;
    sequence: number;
    payload: Record<string, unknown>;
    protocol_version: 1 | 2;
    checksum: number;
    crc_ok: boolean;
    signature?: Uint8Array;
    dialect?: string;
}
interface MAVLinkFrame {
    magic: number;
    length: number;
    incompatible_flags?: number;
    compatible_flags?: number;
    sequence: number;
    system_id: number;
    component_id: number;
    message_id: number;
    payload: Uint8Array;
    checksum: number;
    signature?: Uint8Array;
    crc_ok?: boolean;
    protocol_version?: 1 | 2;
}
interface MessageDefinition {
    id: number;
    name: string;
    fields: FieldDefinition[];
}
interface FieldDefinition {
    name: string;
    type: string;
    arrayLength?: number;
    extension?: boolean;
}
declare abstract class DialectParser {
    protected messageDefinitions: Map<number, MessageDefinition>;
    protected dialectName: string;
    private buffer;
    constructor(dialectName: string);
    abstract loadDefinitions(): Promise<void>;
    parseBytes(data: Uint8Array): ParsedMAVLinkMessage[];
    private tryParseFrame;
    resetBuffer(): void;
    decode(frame: MAVLinkFrame): ParsedMAVLinkMessage;
    private decodePayload;
    private getDefaultValue;
    private decodeField;
    private decodeSingleValue;
    getMessageDefinition(id: number): MessageDefinition | undefined;
    getSupportedMessageIds(): number[];
    getDialectName(): string;
    supportsMessage(messageId: number): boolean;
    serializeMessage(message: Record<string, unknown> & {
        message_name: string;
    }): Uint8Array;
    private extractMessageFields;
    private completeMessageWithDefaults;
    private getDefaultValueForField;
    private serializePayload;
    private serializeField;
    private serializeSingleValue;
    private getFieldSize;
    private getSingleFieldSize;
    private getDefaultValueForType;
    private createMAVLinkFrame;
}
declare class TestParser extends DialectParser {
    constructor();
    loadDefinitions(): Promise<void>;
    private loadDefinitionsSync;
}
declare class TestSerializer {
    private parser;
    constructor();
    serialize(message: Record<string, unknown> & {
        message_name: string;
    }): Uint8Array;
    completeMessage(message: Record<string, unknown> & {
        message_name: string;
    }): Record<string, unknown>;
    getSupportedMessages(): string[];
    supportsMessage(messageName: string): boolean;
}

export { TestParser, TestSerializer, isTestTypes };
export type { AnyMessage, MessageTestTypes, MessageTypeMap, ParsedMAVLinkMessage$1 as ParsedMAVLinkMessage };