import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from 'typed-binary';
declare class UInt64Schema extends Schema<bigint> {
    readonly maxSize = 8;
    read(input: ISerialInput): bigint;
    write(output: ISerialOutput, value: bigint): void;
    measure(_: bigint | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
}
declare class Float64Schema extends Schema<number> {
    readonly maxSize = 8;
    read(input: ISerialInput): number;
    write(output: ISerialOutput, value: number): void;
    measure(_: number | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
}
export declare const actuators_bldc_Id: {
    readonly Fuel: 0;
    readonly Ox: 1;
    readonly Count: 2;
};
export type actuators_bldc_Id = (typeof actuators_bldc_Id)[keyof typeof actuators_bldc_Id];
export declare const BldcCommands_OpenClose: {
    readonly Open: 0;
    readonly Close: 1;
};
export type BldcCommands_OpenClose = (typeof BldcCommands_OpenClose)[keyof typeof BldcCommands_OpenClose];
export declare const StateId: {
    readonly Safe: 0;
    readonly N2Fill: 1;
    readonly PostN2Fill: 2;
    readonly OxFill: 3;
    readonly PostOxFill: 4;
    readonly Pressurized: 5;
    readonly Armed: 6;
    readonly Burn: 7;
    readonly Shutdown: 8;
    readonly Purge: 9;
    readonly Hold: 10;
};
export type StateId = (typeof StateId)[keyof typeof StateId];
export declare const actuators_servo_Id: {
    readonly MainFuel: 0;
    readonly MainOx: 1;
    readonly OxFill: 2;
    readonly OxBoiloff: 3;
    readonly OxPrechill: 4;
    readonly Purge: 5;
    readonly Count: 6;
};
export type actuators_servo_Id = (typeof actuators_servo_Id)[keyof typeof actuators_servo_Id];
export declare const ServoCommands_OpenClose: {
    readonly Open: 0;
    readonly Close: 1;
};
export type ServoCommands_OpenClose = (typeof ServoCommands_OpenClose)[keyof typeof ServoCommands_OpenClose];
export declare const actuators_servo_PositionMode: {
    readonly Absolute: 0;
    readonly Relative: 1;
};
export type actuators_servo_PositionMode = (typeof actuators_servo_PositionMode)[keyof typeof actuators_servo_PositionMode];
export declare const actuators_servo_StartPolicy: {
    readonly Preempt: 0;
    readonly NoInterrupt: 1;
};
export type actuators_servo_StartPolicy = (typeof actuators_servo_StartPolicy)[keyof typeof actuators_servo_StartPolicy];
export declare const actuators_solenoid_Id: {
    readonly FuelVent: 0;
    readonly OxVent: 1;
    readonly N2Fill: 2;
    readonly Count: 3;
};
export type actuators_solenoid_Id = (typeof actuators_solenoid_Id)[keyof typeof actuators_solenoid_Id];
export declare const SolenoidCommands_OpeningType: {
    readonly Open: 0;
    readonly Close: 1;
};
export type SolenoidCommands_OpeningType = (typeof SolenoidCommands_OpeningType)[keyof typeof SolenoidCommands_OpeningType];
export declare const ControlPolicyCommands_PolicyValue: {
    readonly Disable: 0;
    readonly Enable: 1;
};
export type ControlPolicyCommands_PolicyValue = (typeof ControlPolicyCommands_PolicyValue)[keyof typeof ControlPolicyCommands_PolicyValue];
export declare const regulator_Id: {
    readonly OxBoiloff: 0;
    readonly Count: 1;
};
export type regulator_Id = (typeof regulator_Id)[keyof typeof regulator_Id];
export declare const RegulatorCommands_RegulatorValue: {
    readonly Disable: 0;
    readonly Enable: 1;
};
export type RegulatorCommands_RegulatorValue = (typeof RegulatorCommands_RegulatorValue)[keyof typeof RegulatorCommands_RegulatorValue];
export declare const storage_Id: {
    readonly SdCard: 0;
    readonly NandFlash: 1;
    readonly Count: 2;
};
export type storage_Id = (typeof storage_Id)[keyof typeof storage_Id];
export declare const BldcCommands_OpenCloseBldcPayload: import("typed-binary").ObjectSchema<{
    id: import("typed-binary").ByteSchema;
    open_close: import("typed-binary").ByteSchema;
}>;
export type BldcCommands_OpenCloseBldcPayload = bin.Parsed<typeof BldcCommands_OpenCloseBldcPayload>;
export declare const BldcCommands_SetBldcPayload: import("typed-binary").ObjectSchema<{
    id: import("typed-binary").ByteSchema;
    angle_deg: import("typed-binary").Float32Schema;
}>;
export type BldcCommands_SetBldcPayload = bin.Parsed<typeof BldcCommands_SetBldcPayload>;
export declare const BldcCommands_CalibratePayload: import("typed-binary").ObjectSchema<{
    id: import("typed-binary").ByteSchema;
}>;
export type BldcCommands_CalibratePayload = bin.Parsed<typeof BldcCommands_CalibratePayload>;
export declare const actuators_bldc_PidGains: import("typed-binary").ObjectSchema<{
    p: Float64Schema;
    i: Float64Schema;
    d: Float64Schema;
    normalization_factor: Float64Schema;
    integral_clamp: import("typed-binary").BoolSchema;
    integral_clamp_max: Float64Schema;
    integral_clamp_min: Float64Schema;
}>;
export type actuators_bldc_PidGains = bin.Parsed<typeof actuators_bldc_PidGains>;
export declare const SigmoidParameters: import("typed-binary").ObjectSchema<{
    a: Float64Schema;
    b: Float64Schema;
}>;
export type SigmoidParameters = bin.Parsed<typeof SigmoidParameters>;
export declare const actuators_bldc_ControllerConfig: import("typed-binary").ObjectSchema<{
    pressurize_pid_gains: import("typed-binary").ObjectSchema<{
        p: Float64Schema;
        i: Float64Schema;
        d: Float64Schema;
        normalization_factor: Float64Schema;
        integral_clamp: import("typed-binary").BoolSchema;
        integral_clamp_max: Float64Schema;
        integral_clamp_min: Float64Schema;
    }>;
    run_pid_gains: import("typed-binary").ObjectSchema<{
        p: Float64Schema;
        i: Float64Schema;
        d: Float64Schema;
        normalization_factor: Float64Schema;
        integral_clamp: import("typed-binary").BoolSchema;
        integral_clamp_max: Float64Schema;
        integral_clamp_min: Float64Schema;
    }>;
    minimum_position: Float64Schema;
    maximum_position: Float64Schema;
    valve_encoder_offset: Float64Schema;
    can_watchdog_timeout: UInt64Schema;
    end_pressure_ref: Float64Schema;
    pressurizing_time: Float64Schema;
    gear_ratio: import("typed-binary").Float32Schema;
    max_torque: Float64Schema;
    dvdt_nominal: Float64Schema;
    cv_max: Float64Schema;
    control_valve_curve_pressurization: import("typed-binary").ObjectSchema<{
        a: Float64Schema;
        b: Float64Schema;
    }>;
    control_valve_curve_run: import("typed-binary").ObjectSchema<{
        a: Float64Schema;
        b: Float64Schema;
    }>;
    main_valve_curve: import("typed-binary").ObjectSchema<{
        a: Float64Schema;
        b: Float64Schema;
    }>;
}>;
export type actuators_bldc_ControllerConfig = bin.Parsed<typeof actuators_bldc_ControllerConfig>;
export declare const BldcCommands_ConfigureBldcPayload: import("typed-binary").ObjectSchema<{
    id: import("typed-binary").ByteSchema;
    config: import("typed-binary").ObjectSchema<{
        pressurize_pid_gains: import("typed-binary").ObjectSchema<{
            p: Float64Schema;
            i: Float64Schema;
            d: Float64Schema;
            normalization_factor: Float64Schema;
            integral_clamp: import("typed-binary").BoolSchema;
            integral_clamp_max: Float64Schema;
            integral_clamp_min: Float64Schema;
        }>;
        run_pid_gains: import("typed-binary").ObjectSchema<{
            p: Float64Schema;
            i: Float64Schema;
            d: Float64Schema;
            normalization_factor: Float64Schema;
            integral_clamp: import("typed-binary").BoolSchema;
            integral_clamp_max: Float64Schema;
            integral_clamp_min: Float64Schema;
        }>;
        minimum_position: Float64Schema;
        maximum_position: Float64Schema;
        valve_encoder_offset: Float64Schema;
        can_watchdog_timeout: UInt64Schema;
        end_pressure_ref: Float64Schema;
        pressurizing_time: Float64Schema;
        gear_ratio: import("typed-binary").Float32Schema;
        max_torque: Float64Schema;
        dvdt_nominal: Float64Schema;
        cv_max: Float64Schema;
        control_valve_curve_pressurization: import("typed-binary").ObjectSchema<{
            a: Float64Schema;
            b: Float64Schema;
        }>;
        control_valve_curve_run: import("typed-binary").ObjectSchema<{
            a: Float64Schema;
            b: Float64Schema;
        }>;
        main_valve_curve: import("typed-binary").ObjectSchema<{
            a: Float64Schema;
            b: Float64Schema;
        }>;
    }>;
}>;
export type BldcCommands_ConfigureBldcPayload = bin.Parsed<typeof BldcCommands_ConfigureBldcPayload>;
export declare const FsmCommands_NextStatePayload: import("typed-binary").ObjectSchema<{
    current_state: import("typed-binary").ByteSchema;
}>;
export type FsmCommands_NextStatePayload = bin.Parsed<typeof FsmCommands_NextStatePayload>;
export declare const FsmCommands_PreviousStatePayload: import("typed-binary").ObjectSchema<{
    current_state: import("typed-binary").ByteSchema;
}>;
export type FsmCommands_PreviousStatePayload = bin.Parsed<typeof FsmCommands_PreviousStatePayload>;
export declare const FsmCommands_AbortPayload: import("typed-binary").ObjectSchema<{
    reserved: import("typed-binary").ByteSchema;
}>;
export type FsmCommands_AbortPayload = bin.Parsed<typeof FsmCommands_AbortPayload>;
export declare const FsmCommands_StatusPayload: import("typed-binary").ObjectSchema<{
    reserved: import("typed-binary").ByteSchema;
}>;
export type FsmCommands_StatusPayload = bin.Parsed<typeof FsmCommands_StatusPayload>;
export declare const ServoCommands_OpenCloseServoPayload: import("typed-binary").ObjectSchema<{
    servo_id: import("typed-binary").ByteSchema;
    open_close: import("typed-binary").ByteSchema;
    duration_ms: import("typed-binary").Uint16Schema;
    delay_ms: import("typed-binary").Uint16Schema;
    position_mode: import("typed-binary").ByteSchema;
    start_policy: import("typed-binary").ByteSchema;
}>;
export type ServoCommands_OpenCloseServoPayload = bin.Parsed<typeof ServoCommands_OpenCloseServoPayload>;
export declare const ServoCommands_SetServoPayload: import("typed-binary").ObjectSchema<{
    servo_id: import("typed-binary").ByteSchema;
    angle_deg: import("typed-binary").Float32Schema;
    duration_ms: import("typed-binary").Uint16Schema;
    delay_ms: import("typed-binary").Uint16Schema;
    position_mode: import("typed-binary").ByteSchema;
    start_policy: import("typed-binary").ByteSchema;
}>;
export type ServoCommands_SetServoPayload = bin.Parsed<typeof ServoCommands_SetServoPayload>;
export declare const SolenoidCommands_OpenCloseSolenoidPayload: import("typed-binary").ObjectSchema<{
    solenoid_id: import("typed-binary").ByteSchema;
    opening_type: import("typed-binary").ByteSchema;
}>;
export type SolenoidCommands_OpenCloseSolenoidPayload = bin.Parsed<typeof SolenoidCommands_OpenCloseSolenoidPayload>;
export declare const ControlPolicyCommands_SetManualPolicyPayload: import("typed-binary").ObjectSchema<{
    value: import("typed-binary").ByteSchema;
}>;
export type ControlPolicyCommands_SetManualPolicyPayload = bin.Parsed<typeof ControlPolicyCommands_SetManualPolicyPayload>;
export declare const LinkMonitorCommands_MarkSeenPayload: import("typed-binary").ObjectSchema<{
    payload: import("typed-binary").ByteSchema;
}>;
export type LinkMonitorCommands_MarkSeenPayload = bin.Parsed<typeof LinkMonitorCommands_MarkSeenPayload>;
export declare const RegulatorCommands_SetEnabledPayload: import("typed-binary").ObjectSchema<{
    regulator_id: import("typed-binary").ByteSchema;
    value: import("typed-binary").ByteSchema;
}>;
export type RegulatorCommands_SetEnabledPayload = bin.Parsed<typeof RegulatorCommands_SetEnabledPayload>;
export declare const RegulatorCommands_SetSetpointPayload: import("typed-binary").ObjectSchema<{
    regulator_id: import("typed-binary").ByteSchema;
    setpoint: import("typed-binary").Float32Schema;
}>;
export type RegulatorCommands_SetSetpointPayload = bin.Parsed<typeof RegulatorCommands_SetSetpointPayload>;
export declare const RegulatorCommands_SetGainsPayload: import("typed-binary").ObjectSchema<{
    regulator_id: import("typed-binary").ByteSchema;
    kp: import("typed-binary").Float32Schema;
    ki: import("typed-binary").Float32Schema;
    kd: import("typed-binary").Float32Schema;
}>;
export type RegulatorCommands_SetGainsPayload = bin.Parsed<typeof RegulatorCommands_SetGainsPayload>;
export declare const StorageCommands_FormatStoragePayload: import("typed-binary").ObjectSchema<{
    storage_id: import("typed-binary").ByteSchema;
}>;
export type StorageCommands_FormatStoragePayload = bin.Parsed<typeof StorageCommands_FormatStoragePayload>;
export declare const StorageCommands_StartTransferPayload: import("typed-binary").ObjectSchema<{
    source_id: import("typed-binary").ByteSchema;
    destination_id: import("typed-binary").ByteSchema;
}>;
export type StorageCommands_StartTransferPayload = bin.Parsed<typeof StorageCommands_StartTransferPayload>;
export declare const spec: {
    BldcCommands_OpenCloseBldcPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            id: import("typed-binary").ByteSchema;
            open_close: import("typed-binary").ByteSchema;
        }>;
        enums: {
            id: {
                readonly Fuel: 0;
                readonly Ox: 1;
                readonly Count: 2;
            };
            open_close: {
                readonly Open: 0;
                readonly Close: 1;
            };
        };
    };
    BldcCommands_SetBldcPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            id: import("typed-binary").ByteSchema;
            angle_deg: import("typed-binary").Float32Schema;
        }>;
        enums: {
            id: {
                readonly Fuel: 0;
                readonly Ox: 1;
                readonly Count: 2;
            };
        };
    };
    BldcCommands_CalibratePayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            id: import("typed-binary").ByteSchema;
        }>;
        enums: {
            id: {
                readonly Fuel: 0;
                readonly Ox: 1;
                readonly Count: 2;
            };
        };
    };
    BldcCommands_ConfigureBldcPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            id: import("typed-binary").ByteSchema;
            config: import("typed-binary").ObjectSchema<{
                pressurize_pid_gains: import("typed-binary").ObjectSchema<{
                    p: Float64Schema;
                    i: Float64Schema;
                    d: Float64Schema;
                    normalization_factor: Float64Schema;
                    integral_clamp: import("typed-binary").BoolSchema;
                    integral_clamp_max: Float64Schema;
                    integral_clamp_min: Float64Schema;
                }>;
                run_pid_gains: import("typed-binary").ObjectSchema<{
                    p: Float64Schema;
                    i: Float64Schema;
                    d: Float64Schema;
                    normalization_factor: Float64Schema;
                    integral_clamp: import("typed-binary").BoolSchema;
                    integral_clamp_max: Float64Schema;
                    integral_clamp_min: Float64Schema;
                }>;
                minimum_position: Float64Schema;
                maximum_position: Float64Schema;
                valve_encoder_offset: Float64Schema;
                can_watchdog_timeout: UInt64Schema;
                end_pressure_ref: Float64Schema;
                pressurizing_time: Float64Schema;
                gear_ratio: import("typed-binary").Float32Schema;
                max_torque: Float64Schema;
                dvdt_nominal: Float64Schema;
                cv_max: Float64Schema;
                control_valve_curve_pressurization: import("typed-binary").ObjectSchema<{
                    a: Float64Schema;
                    b: Float64Schema;
                }>;
                control_valve_curve_run: import("typed-binary").ObjectSchema<{
                    a: Float64Schema;
                    b: Float64Schema;
                }>;
                main_valve_curve: import("typed-binary").ObjectSchema<{
                    a: Float64Schema;
                    b: Float64Schema;
                }>;
            }>;
        }>;
        enums: {
            id: {
                readonly Fuel: 0;
                readonly Ox: 1;
                readonly Count: 2;
            };
            config: {
                pressurize_pid_gains: {};
                run_pid_gains: {};
                control_valve_curve_pressurization: {};
                control_valve_curve_run: {};
                main_valve_curve: {};
            };
        };
    };
    FsmCommands_NextStatePayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            current_state: import("typed-binary").ByteSchema;
        }>;
        enums: {
            current_state: {
                readonly Safe: 0;
                readonly N2Fill: 1;
                readonly PostN2Fill: 2;
                readonly OxFill: 3;
                readonly PostOxFill: 4;
                readonly Pressurized: 5;
                readonly Armed: 6;
                readonly Burn: 7;
                readonly Shutdown: 8;
                readonly Purge: 9;
                readonly Hold: 10;
            };
        };
    };
    FsmCommands_PreviousStatePayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            current_state: import("typed-binary").ByteSchema;
        }>;
        enums: {
            current_state: {
                readonly Safe: 0;
                readonly N2Fill: 1;
                readonly PostN2Fill: 2;
                readonly OxFill: 3;
                readonly PostOxFill: 4;
                readonly Pressurized: 5;
                readonly Armed: 6;
                readonly Burn: 7;
                readonly Shutdown: 8;
                readonly Purge: 9;
                readonly Hold: 10;
            };
        };
    };
    FsmCommands_AbortPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            reserved: import("typed-binary").ByteSchema;
        }>;
        enums: {};
    };
    FsmCommands_StatusPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            reserved: import("typed-binary").ByteSchema;
        }>;
        enums: {};
    };
    ServoCommands_OpenCloseServoPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            servo_id: import("typed-binary").ByteSchema;
            open_close: import("typed-binary").ByteSchema;
            duration_ms: import("typed-binary").Uint16Schema;
            delay_ms: import("typed-binary").Uint16Schema;
            position_mode: import("typed-binary").ByteSchema;
            start_policy: import("typed-binary").ByteSchema;
        }>;
        enums: {
            servo_id: {
                readonly MainFuel: 0;
                readonly MainOx: 1;
                readonly OxFill: 2;
                readonly OxBoiloff: 3;
                readonly OxPrechill: 4;
                readonly Purge: 5;
                readonly Count: 6;
            };
            open_close: {
                readonly Open: 0;
                readonly Close: 1;
            };
            position_mode: {
                readonly Absolute: 0;
                readonly Relative: 1;
            };
            start_policy: {
                readonly Preempt: 0;
                readonly NoInterrupt: 1;
            };
        };
    };
    ServoCommands_SetServoPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            servo_id: import("typed-binary").ByteSchema;
            angle_deg: import("typed-binary").Float32Schema;
            duration_ms: import("typed-binary").Uint16Schema;
            delay_ms: import("typed-binary").Uint16Schema;
            position_mode: import("typed-binary").ByteSchema;
            start_policy: import("typed-binary").ByteSchema;
        }>;
        enums: {
            servo_id: {
                readonly MainFuel: 0;
                readonly MainOx: 1;
                readonly OxFill: 2;
                readonly OxBoiloff: 3;
                readonly OxPrechill: 4;
                readonly Purge: 5;
                readonly Count: 6;
            };
            position_mode: {
                readonly Absolute: 0;
                readonly Relative: 1;
            };
            start_policy: {
                readonly Preempt: 0;
                readonly NoInterrupt: 1;
            };
        };
    };
    SolenoidCommands_OpenCloseSolenoidPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            solenoid_id: import("typed-binary").ByteSchema;
            opening_type: import("typed-binary").ByteSchema;
        }>;
        enums: {
            solenoid_id: {
                readonly FuelVent: 0;
                readonly OxVent: 1;
                readonly N2Fill: 2;
                readonly Count: 3;
            };
            opening_type: {
                readonly Open: 0;
                readonly Close: 1;
            };
        };
    };
    ControlPolicyCommands_SetManualPolicyPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            value: import("typed-binary").ByteSchema;
        }>;
        enums: {
            value: {
                readonly Disable: 0;
                readonly Enable: 1;
            };
        };
    };
    LinkMonitorCommands_MarkSeenPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            payload: import("typed-binary").ByteSchema;
        }>;
        enums: {};
    };
    RegulatorCommands_SetEnabledPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            regulator_id: import("typed-binary").ByteSchema;
            value: import("typed-binary").ByteSchema;
        }>;
        enums: {
            regulator_id: {
                readonly OxBoiloff: 0;
                readonly Count: 1;
            };
            value: {
                readonly Disable: 0;
                readonly Enable: 1;
            };
        };
    };
    RegulatorCommands_SetSetpointPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            regulator_id: import("typed-binary").ByteSchema;
            setpoint: import("typed-binary").Float32Schema;
        }>;
        enums: {
            regulator_id: {
                readonly OxBoiloff: 0;
                readonly Count: 1;
            };
        };
    };
    RegulatorCommands_SetGainsPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            regulator_id: import("typed-binary").ByteSchema;
            kp: import("typed-binary").Float32Schema;
            ki: import("typed-binary").Float32Schema;
            kd: import("typed-binary").Float32Schema;
        }>;
        enums: {
            regulator_id: {
                readonly OxBoiloff: 0;
                readonly Count: 1;
            };
        };
    };
    StorageCommands_FormatStoragePayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            storage_id: import("typed-binary").ByteSchema;
        }>;
        enums: {
            storage_id: {
                readonly SdCard: 0;
                readonly NandFlash: 1;
                readonly Count: 2;
            };
        };
    };
    StorageCommands_StartTransferPayload: {
        id: number;
        schema: import("typed-binary").ObjectSchema<{
            source_id: import("typed-binary").ByteSchema;
            destination_id: import("typed-binary").ByteSchema;
        }>;
        enums: {
            source_id: {
                readonly SdCard: 0;
                readonly NandFlash: 1;
                readonly Count: 2;
            };
            destination_id: {
                readonly SdCard: 0;
                readonly NandFlash: 1;
                readonly Count: 2;
            };
        };
    };
};
export default spec;
export type Spec = typeof spec;