import { Any, AnyProtoMsg, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
import { Duration, DurationAmino, DurationSDKType } from "../../../google/protobuf/duration";
import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
import { TimeoutPolicy } from "../../../stride/interchainquery/v1/genesis";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { JsonSafe } from "../../../json-safe";
/** Comparison operators that can be used for various types. */
export declare enum ComparisonOperator {
    /** EQUAL - Equality check (for all types) */
    EQUAL = 0,
    /** CONTAINS - Contains check (for strings, arrays, etc.) */
    CONTAINS = 1,
    /** NOT_CONTAINS - Not contains check (for strings, arrays, etc.) */
    NOT_CONTAINS = 2,
    /** SMALLER_THAN - Less than check (for numeric types) */
    SMALLER_THAN = 3,
    /** LARGER_THAN - Greater than check (for numeric types) */
    LARGER_THAN = 4,
    /** GREATER_EQUAL - Greater than or equal to check (for numeric types) */
    GREATER_EQUAL = 5,
    /** LESS_EQUAL - Less than or equal to check (for numeric types) */
    LESS_EQUAL = 6,
    /** STARTS_WITH - Starts with check (for strings) */
    STARTS_WITH = 7,
    /** ENDS_WITH - Ends with check (for strings) */
    ENDS_WITH = 8,
    /** NOT_EQUAL - Not equal check (for all types) */
    NOT_EQUAL = 9,
    UNRECOGNIZED = -1
}
export declare const ComparisonOperatorSDKType: typeof ComparisonOperator;
export declare const ComparisonOperatorAmino: typeof ComparisonOperator;
export declare function comparisonOperatorFromJSON(object: any): ComparisonOperator;
export declare function comparisonOperatorToJSON(object: ComparisonOperator): string;
/** Flow stores the info for the flow */
export interface Flow {
    id: bigint;
    owner: string;
    label: string;
    feeAddress: string;
    msgs: (Any)[] | Any[];
    interval: Duration;
    startTime: Date;
    execTime: Date;
    endTime: Date;
    updateHistory: Date[];
    selfHostedIca?: ICAConfig;
    trustlessAgent?: TrustlessAgentConfig;
    configuration?: ExecutionConfiguration;
    conditions?: ExecutionConditions;
}
export interface FlowProtoMsg {
    typeUrl: "/intento.intent.v1.Flow";
    value: Uint8Array;
}
export type FlowEncoded = Omit<Flow, "msgs"> & {
    msgs: (AnyProtoMsg)[];
};
/**
 * Flow stores the info for the flow
 * @name FlowAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.Flow
 */
export interface FlowAmino {
    id?: string;
    owner?: string;
    label?: string;
    fee_address?: string;
    msgs?: AnyAmino[];
    interval?: DurationAmino;
    start_time?: string;
    exec_time?: string;
    end_time?: string;
    update_history?: string[];
    self_hosted_ica?: ICAConfigAmino;
    trustless_agent?: TrustlessAgentConfigAmino;
    configuration?: ExecutionConfigurationAmino;
    conditions?: ExecutionConditionsAmino;
}
export interface FlowAminoMsg {
    type: "/intento.intent.v1.Flow";
    value: FlowAmino;
}
/** Flow stores the info for the flow */
export interface FlowSDKType {
    id: bigint;
    owner: string;
    label: string;
    fee_address: string;
    msgs: (AnySDKType)[];
    interval: DurationSDKType;
    start_time: Date;
    exec_time: Date;
    end_time: Date;
    update_history: Date[];
    self_hosted_ica?: ICAConfigSDKType;
    trustless_agent?: TrustlessAgentConfigSDKType;
    configuration?: ExecutionConfigurationSDKType;
    conditions?: ExecutionConditionsSDKType;
}
/** base config for ICA */
export interface ICAConfig {
    portId: string;
    connectionId: string;
}
export interface ICAConfigProtoMsg {
    typeUrl: "/intento.intent.v1.ICAConfig";
    value: Uint8Array;
}
/**
 * base config for ICA
 * @name ICAConfigAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.ICAConfig
 */
export interface ICAConfigAmino {
    port_id?: string;
    connection_id?: string;
}
export interface ICAConfigAminoMsg {
    type: "/intento.intent.v1.ICAConfig";
    value: ICAConfigAmino;
}
/** base config for ICA */
export interface ICAConfigSDKType {
    port_id: string;
    connection_id: string;
}
/** config for a trustless agent for flow execution on host chain */
export interface TrustlessAgentConfig {
    agentAddress: string;
    /** optional, if set to empty array, no fee limit is set and no fees are charged */
    feeLimit: Coin[];
    /** optional for display */
    connectionId: string;
}
export interface TrustlessAgentConfigProtoMsg {
    typeUrl: "/intento.intent.v1.TrustlessAgentConfig";
    value: Uint8Array;
}
/**
 * config for a trustless agent for flow execution on host chain
 * @name TrustlessAgentConfigAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.TrustlessAgentConfig
 */
export interface TrustlessAgentConfigAmino {
    agent_address?: string;
    /**
     * optional, if set to empty array, no fee limit is set and no fees are charged
     */
    fee_limit?: CoinAmino[];
    /**
     * optional for display
     */
    connection_id?: string;
}
export interface TrustlessAgentConfigAminoMsg {
    type: "/intento.intent.v1.TrustlessAgentConfig";
    value: TrustlessAgentConfigAmino;
}
/** config for a trustless agent for flow execution on host chain */
export interface TrustlessAgentConfigSDKType {
    agent_address: string;
    fee_limit: CoinSDKType[];
    connection_id: string;
}
/**
 * ExecutionConfiguration provides the execution-related configuration of the
 * flow
 */
export interface ExecutionConfiguration {
    /** if true, the flow response outputs are saved and can be used in logic */
    saveResponses: boolean;
    /** if true, the flow is not updatable */
    updatingDisabled: boolean;
    /**
     * If true, will execute until we get a successful flow execution, if false/unset will
     * always execute
     */
    stopOnSuccess: boolean;
    /**
     * If true, will execute until flow execution is successful, if false/unset will always
     * execute
     */
    stopOnFailure: boolean;
    /** If true, will stop if flow execution on the host chain times out */
    stopOnTimeout: boolean;
    /** If true, will use the owner account balance when flow account funds run out */
    walletFallback: boolean;
}
export interface ExecutionConfigurationProtoMsg {
    typeUrl: "/intento.intent.v1.ExecutionConfiguration";
    value: Uint8Array;
}
/**
 * ExecutionConfiguration provides the execution-related configuration of the
 * flow
 * @name ExecutionConfigurationAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.ExecutionConfiguration
 */
export interface ExecutionConfigurationAmino {
    /**
     * if true, the flow response outputs are saved and can be used in logic
     */
    save_responses?: boolean;
    /**
     * if true, the flow is not updatable
     */
    updating_disabled?: boolean;
    /**
     * If true, will execute until we get a successful flow execution, if false/unset will
     * always execute
     */
    stop_on_success?: boolean;
    /**
     * If true, will execute until flow execution is successful, if false/unset will always
     * execute
     */
    stop_on_failure?: boolean;
    /**
     * If true, will stop if flow execution on the host chain times out
     */
    stop_on_timeout?: boolean;
    /**
     * If true, will use the owner account balance when flow account funds run out
     */
    wallet_fallback?: boolean;
}
export interface ExecutionConfigurationAminoMsg {
    type: "/intento.intent.v1.ExecutionConfiguration";
    value: ExecutionConfigurationAmino;
}
/**
 * ExecutionConfiguration provides the execution-related configuration of the
 * flow
 */
export interface ExecutionConfigurationSDKType {
    save_responses: boolean;
    updating_disabled: boolean;
    stop_on_success: boolean;
    stop_on_failure: boolean;
    stop_on_timeout: boolean;
    wallet_fallback: boolean;
}
/** FlowHistory execution history */
export interface FlowHistory {
    history: FlowHistoryEntry[];
}
export interface FlowHistoryProtoMsg {
    typeUrl: "/intento.intent.v1.FlowHistory";
    value: Uint8Array;
}
/**
 * FlowHistory execution history
 * @name FlowHistoryAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.FlowHistory
 */
export interface FlowHistoryAmino {
    history?: FlowHistoryEntryAmino[];
}
export interface FlowHistoryAminoMsg {
    type: "/intento.intent.v1.FlowHistory";
    value: FlowHistoryAmino;
}
/** FlowHistory execution history */
export interface FlowHistorySDKType {
    history: FlowHistoryEntrySDKType[];
}
/** FlowHistoryEntry provides a the history of flow interchain tx call */
export interface FlowHistoryEntry {
    scheduledExecTime: Date;
    actualExecTime: Date;
    execFee: Coin[];
    /** whether all messages are executed, independent of succesfull result */
    executed: boolean;
    /** timed out from execution over IBC */
    timedOut: boolean;
    /**
     * errors from execution, if executed and no error the execution was
     * succesfull
     */
    errors: string[];
    /** will be empty when save_responses is false */
    msgResponses: Any[];
    /** will be empty when save_responses is false */
    queryResponses: string[];
    /** packet sequences of the flow execution on the host chain */
    packetSequences: bigint[];
}
export interface FlowHistoryEntryProtoMsg {
    typeUrl: "/intento.intent.v1.FlowHistoryEntry";
    value: Uint8Array;
}
/**
 * FlowHistoryEntry provides a the history of flow interchain tx call
 * @name FlowHistoryEntryAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.FlowHistoryEntry
 */
export interface FlowHistoryEntryAmino {
    scheduled_exec_time?: string;
    actual_exec_time?: string;
    exec_fee?: CoinAmino[];
    /**
     * whether all messages are executed, independent of succesfull result
     */
    executed?: boolean;
    /**
     * timed out from execution over IBC
     */
    timed_out?: boolean;
    /**
     * errors from execution, if executed and no error the execution was
     * succesfull
     */
    errors?: string[];
    /**
     * will be empty when save_responses is false
     */
    msg_responses?: AnyAmino[];
    /**
     * will be empty when save_responses is false
     */
    query_responses?: string[];
    /**
     * packet sequences of the flow execution on the host chain
     */
    packet_sequences?: string[];
}
export interface FlowHistoryEntryAminoMsg {
    type: "/intento.intent.v1.FlowHistoryEntry";
    value: FlowHistoryEntryAmino;
}
/** FlowHistoryEntry provides a the history of flow interchain tx call */
export interface FlowHistoryEntrySDKType {
    scheduled_exec_time: Date;
    actual_exec_time: Date;
    exec_fee: CoinSDKType[];
    executed: boolean;
    timed_out: boolean;
    errors: string[];
    msg_responses: AnySDKType[];
    query_responses: string[];
    packet_sequences: bigint[];
}
/** ExecutionConditions provides execution conditions for the flow */
export interface ExecutionConditions {
    /**
     * Replace value with value from message or response from another flow’s
     * latest output
     */
    feedbackLoops: FeedbackLoop[];
    /** Comparison with response response value */
    comparisons: Comparison[];
    /**
     * optional array of dependent intents that when executing succesfully, stops
     * execution
     */
    stopOnSuccessOf: bigint[];
    /**
     * optional array of dependent intents that when not executing succesfully,
     * stops execution
     */
    stopOnFailureOf: bigint[];
    /**
     * optional array of dependent intents that should be executed succesfully
     * after their latest call before execution is allowed
     */
    skipOnFailureOf: bigint[];
    /**
     * optional array of dependent intents that should fail after their latest
     * call before execution is allowed
     */
    skipOnSuccessOf: bigint[];
    /** True: Use AND for combining comparisons. False: Use OR for combining comparisons. */
    useAndForComparisons: boolean;
}
export interface ExecutionConditionsProtoMsg {
    typeUrl: "/intento.intent.v1.ExecutionConditions";
    value: Uint8Array;
}
/**
 * ExecutionConditions provides execution conditions for the flow
 * @name ExecutionConditionsAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.ExecutionConditions
 */
export interface ExecutionConditionsAmino {
    /**
     * Replace value with value from message or response from another flow’s
     * latest output
     */
    feedback_loops?: FeedbackLoopAmino[];
    /**
     * Comparison with response response value
     */
    comparisons?: ComparisonAmino[];
    /**
     * optional array of dependent intents that when executing succesfully, stops
     * execution
     */
    stop_on_success_of?: string[];
    /**
     * optional array of dependent intents that when not executing succesfully,
     * stops execution
     */
    stop_on_failure_of?: string[];
    /**
     * optional array of dependent intents that should be executed succesfully
     * after their latest call before execution is allowed
     */
    skip_on_failure_of?: string[];
    /**
     * optional array of dependent intents that should fail after their latest
     * call before execution is allowed
     */
    skip_on_success_of?: string[];
    /**
     * True: Use AND for combining comparisons. False: Use OR for combining comparisons.
     */
    use_and_for_comparisons?: boolean;
}
export interface ExecutionConditionsAminoMsg {
    type: "/intento.intent.v1.ExecutionConditions";
    value: ExecutionConditionsAmino;
}
/** ExecutionConditions provides execution conditions for the flow */
export interface ExecutionConditionsSDKType {
    feedback_loops: FeedbackLoopSDKType[];
    comparisons: ComparisonSDKType[];
    stop_on_success_of: bigint[];
    stop_on_failure_of: bigint[];
    skip_on_failure_of: bigint[];
    skip_on_success_of: bigint[];
    use_and_for_comparisons: boolean;
}
/**
 * Replace value with value from message or response from another flow’s
 * latest output before execution
 */
export interface FeedbackLoop {
    /** flow to get the latest response value from, optional */
    flowId: bigint;
    /** index of the responses */
    responseIndex: number;
    /** for example "Amount" */
    responseKey: string;
    /** index of the msg to replace */
    msgsIndex: number;
    /** key of the message to replace (e.g. Amount[0].Amount, FromAddress) */
    msgKey: string;
    /** can be anything from math.Int, sdk.Coin, sdk.Coins, string, []string, []math.Int, math.Dec */
    valueType: string;
    /** True: calculate the difference with the previous value instead of using the value directly. */
    differenceMode: boolean;
    /** config of ICQ to perform */
    icqConfig?: ICQConfig;
}
export interface FeedbackLoopProtoMsg {
    typeUrl: "/intento.intent.v1.FeedbackLoop";
    value: Uint8Array;
}
/**
 * Replace value with value from message or response from another flow’s
 * latest output before execution
 * @name FeedbackLoopAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.FeedbackLoop
 */
export interface FeedbackLoopAmino {
    /**
     * flow to get the latest response value from, optional
     */
    flow_id?: string;
    /**
     * index of the responses
     */
    response_index?: number;
    /**
     * for example "Amount"
     */
    response_key?: string;
    /**
     * index of the msg to replace
     */
    msgs_index?: number;
    /**
     * key of the message to replace (e.g. Amount[0].Amount, FromAddress)
     */
    msg_key?: string;
    /**
     * can be anything from math.Int, sdk.Coin, sdk.Coins, string, []string, []math.Int, math.Dec
     */
    value_type?: string;
    /**
     * True: calculate the difference with the previous value instead of using the value directly.
     */
    difference_mode?: boolean;
    /**
     * config of ICQ to perform
     */
    icq_config?: ICQConfigAmino;
}
export interface FeedbackLoopAminoMsg {
    type: "/intento.intent.v1.FeedbackLoop";
    value: FeedbackLoopAmino;
}
/**
 * Replace value with value from message or response from another flow’s
 * latest output before execution
 */
export interface FeedbackLoopSDKType {
    flow_id: bigint;
    response_index: number;
    response_key: string;
    msgs_index: number;
    msg_key: string;
    value_type: string;
    difference_mode: boolean;
    icq_config?: ICQConfigSDKType;
}
/**
 * Comparison is checked on the response in JSON before execution of
 * flow and outputs true or false
 */
export interface Comparison {
    /** get the latest response value from other flow, optional */
    flowId: bigint;
    /** index of the message response, optional */
    responseIndex: number;
    /** e.g. Amount[0].Amount, FromAddress, optional */
    responseKey: string;
    /** can be anything from math.Int, sdk.Coin, sdk.Coins, string, []string, []math.Int,  math.Dec */
    valueType: string;
    operator: ComparisonOperator;
    operand: string;
    /** True: Calculate the difference with the previous value. */
    differenceMode: boolean;
    /** config of ICQ to perform */
    icqConfig?: ICQConfig;
}
export interface ComparisonProtoMsg {
    typeUrl: "/intento.intent.v1.Comparison";
    value: Uint8Array;
}
/**
 * Comparison is checked on the response in JSON before execution of
 * flow and outputs true or false
 * @name ComparisonAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.Comparison
 */
export interface ComparisonAmino {
    /**
     * get the latest response value from other flow, optional
     */
    flow_id?: string;
    /**
     * index of the message response, optional
     */
    response_index?: number;
    /**
     * e.g. Amount[0].Amount, FromAddress, optional
     */
    response_key?: string;
    /**
     * can be anything from math.Int, sdk.Coin, sdk.Coins, string, []string, []math.Int,  math.Dec
     */
    value_type?: string;
    operator?: ComparisonOperator;
    operand?: string;
    /**
     * True: Calculate the difference with the previous value.
     */
    difference_mode?: boolean;
    /**
     * config of ICQ to perform
     */
    icq_config?: ICQConfigAmino;
}
export interface ComparisonAminoMsg {
    type: "/intento.intent.v1.Comparison";
    value: ComparisonAmino;
}
/**
 * Comparison is checked on the response in JSON before execution of
 * flow and outputs true or false
 */
export interface ComparisonSDKType {
    flow_id: bigint;
    response_index: number;
    response_key: string;
    value_type: string;
    operator: ComparisonOperator;
    operand: string;
    difference_mode: boolean;
    icq_config?: ICQConfigSDKType;
}
/** config for using interchain queries */
export interface ICQConfig {
    connectionId: string;
    chainId: string;
    timeoutPolicy: TimeoutPolicy;
    timeoutDuration: Duration;
    /** e.g. store/bank/key store/staking/key */
    queryType: string;
    /** key in the store that stores the query e.g. stakingtypes.GetValidatorKey(validatorAddressBz) */
    queryKey: string;
    /** should be reset after execution */
    response: Uint8Array;
}
export interface ICQConfigProtoMsg {
    typeUrl: "/intento.intent.v1.ICQConfig";
    value: Uint8Array;
}
/**
 * config for using interchain queries
 * @name ICQConfigAmino
 * @package intento.intent.v1
 * @see proto type: intento.intent.v1.ICQConfig
 */
export interface ICQConfigAmino {
    connection_id?: string;
    chain_id?: string;
    timeout_policy?: TimeoutPolicy;
    timeout_duration?: DurationAmino;
    /**
     * e.g. store/bank/key store/staking/key
     */
    query_type?: string;
    /**
     * key in the store that stores the query e.g. stakingtypes.GetValidatorKey(validatorAddressBz)
     */
    query_key?: string;
    /**
     * should be reset after execution
     */
    response?: string;
}
export interface ICQConfigAminoMsg {
    type: "/intento.intent.v1.ICQConfig";
    value: ICQConfigAmino;
}
/** config for using interchain queries */
export interface ICQConfigSDKType {
    connection_id: string;
    chain_id: string;
    timeout_policy: TimeoutPolicy;
    timeout_duration: DurationSDKType;
    query_type: string;
    query_key: string;
    response: Uint8Array;
}
export declare const Flow: {
    typeUrl: string;
    is(o: any): o is Flow;
    isSDK(o: any): o is FlowSDKType;
    isAmino(o: any): o is FlowAmino;
    encode(message: Flow, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Flow;
    fromJSON(object: any): Flow;
    toJSON(message: Flow): JsonSafe<Flow>;
    fromPartial(object: Partial<Flow>): Flow;
    fromAmino(object: FlowAmino): Flow;
    toAmino(message: Flow): FlowAmino;
    fromAminoMsg(object: FlowAminoMsg): Flow;
    fromProtoMsg(message: FlowProtoMsg): Flow;
    toProto(message: Flow): Uint8Array;
    toProtoMsg(message: Flow): FlowProtoMsg;
};
export declare const ICAConfig: {
    typeUrl: string;
    is(o: any): o is ICAConfig;
    isSDK(o: any): o is ICAConfigSDKType;
    isAmino(o: any): o is ICAConfigAmino;
    encode(message: ICAConfig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ICAConfig;
    fromJSON(object: any): ICAConfig;
    toJSON(message: ICAConfig): JsonSafe<ICAConfig>;
    fromPartial(object: Partial<ICAConfig>): ICAConfig;
    fromAmino(object: ICAConfigAmino): ICAConfig;
    toAmino(message: ICAConfig): ICAConfigAmino;
    fromAminoMsg(object: ICAConfigAminoMsg): ICAConfig;
    fromProtoMsg(message: ICAConfigProtoMsg): ICAConfig;
    toProto(message: ICAConfig): Uint8Array;
    toProtoMsg(message: ICAConfig): ICAConfigProtoMsg;
};
export declare const TrustlessAgentConfig: {
    typeUrl: string;
    is(o: any): o is TrustlessAgentConfig;
    isSDK(o: any): o is TrustlessAgentConfigSDKType;
    isAmino(o: any): o is TrustlessAgentConfigAmino;
    encode(message: TrustlessAgentConfig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TrustlessAgentConfig;
    fromJSON(object: any): TrustlessAgentConfig;
    toJSON(message: TrustlessAgentConfig): JsonSafe<TrustlessAgentConfig>;
    fromPartial(object: Partial<TrustlessAgentConfig>): TrustlessAgentConfig;
    fromAmino(object: TrustlessAgentConfigAmino): TrustlessAgentConfig;
    toAmino(message: TrustlessAgentConfig): TrustlessAgentConfigAmino;
    fromAminoMsg(object: TrustlessAgentConfigAminoMsg): TrustlessAgentConfig;
    fromProtoMsg(message: TrustlessAgentConfigProtoMsg): TrustlessAgentConfig;
    toProto(message: TrustlessAgentConfig): Uint8Array;
    toProtoMsg(message: TrustlessAgentConfig): TrustlessAgentConfigProtoMsg;
};
export declare const ExecutionConfiguration: {
    typeUrl: string;
    is(o: any): o is ExecutionConfiguration;
    isSDK(o: any): o is ExecutionConfigurationSDKType;
    isAmino(o: any): o is ExecutionConfigurationAmino;
    encode(message: ExecutionConfiguration, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ExecutionConfiguration;
    fromJSON(object: any): ExecutionConfiguration;
    toJSON(message: ExecutionConfiguration): JsonSafe<ExecutionConfiguration>;
    fromPartial(object: Partial<ExecutionConfiguration>): ExecutionConfiguration;
    fromAmino(object: ExecutionConfigurationAmino): ExecutionConfiguration;
    toAmino(message: ExecutionConfiguration): ExecutionConfigurationAmino;
    fromAminoMsg(object: ExecutionConfigurationAminoMsg): ExecutionConfiguration;
    fromProtoMsg(message: ExecutionConfigurationProtoMsg): ExecutionConfiguration;
    toProto(message: ExecutionConfiguration): Uint8Array;
    toProtoMsg(message: ExecutionConfiguration): ExecutionConfigurationProtoMsg;
};
export declare const FlowHistory: {
    typeUrl: string;
    is(o: any): o is FlowHistory;
    isSDK(o: any): o is FlowHistorySDKType;
    isAmino(o: any): o is FlowHistoryAmino;
    encode(message: FlowHistory, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): FlowHistory;
    fromJSON(object: any): FlowHistory;
    toJSON(message: FlowHistory): JsonSafe<FlowHistory>;
    fromPartial(object: Partial<FlowHistory>): FlowHistory;
    fromAmino(object: FlowHistoryAmino): FlowHistory;
    toAmino(message: FlowHistory): FlowHistoryAmino;
    fromAminoMsg(object: FlowHistoryAminoMsg): FlowHistory;
    fromProtoMsg(message: FlowHistoryProtoMsg): FlowHistory;
    toProto(message: FlowHistory): Uint8Array;
    toProtoMsg(message: FlowHistory): FlowHistoryProtoMsg;
};
export declare const FlowHistoryEntry: {
    typeUrl: string;
    is(o: any): o is FlowHistoryEntry;
    isSDK(o: any): o is FlowHistoryEntrySDKType;
    isAmino(o: any): o is FlowHistoryEntryAmino;
    encode(message: FlowHistoryEntry, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): FlowHistoryEntry;
    fromJSON(object: any): FlowHistoryEntry;
    toJSON(message: FlowHistoryEntry): JsonSafe<FlowHistoryEntry>;
    fromPartial(object: Partial<FlowHistoryEntry>): FlowHistoryEntry;
    fromAmino(object: FlowHistoryEntryAmino): FlowHistoryEntry;
    toAmino(message: FlowHistoryEntry): FlowHistoryEntryAmino;
    fromAminoMsg(object: FlowHistoryEntryAminoMsg): FlowHistoryEntry;
    fromProtoMsg(message: FlowHistoryEntryProtoMsg): FlowHistoryEntry;
    toProto(message: FlowHistoryEntry): Uint8Array;
    toProtoMsg(message: FlowHistoryEntry): FlowHistoryEntryProtoMsg;
};
export declare const ExecutionConditions: {
    typeUrl: string;
    is(o: any): o is ExecutionConditions;
    isSDK(o: any): o is ExecutionConditionsSDKType;
    isAmino(o: any): o is ExecutionConditionsAmino;
    encode(message: ExecutionConditions, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ExecutionConditions;
    fromJSON(object: any): ExecutionConditions;
    toJSON(message: ExecutionConditions): JsonSafe<ExecutionConditions>;
    fromPartial(object: Partial<ExecutionConditions>): ExecutionConditions;
    fromAmino(object: ExecutionConditionsAmino): ExecutionConditions;
    toAmino(message: ExecutionConditions): ExecutionConditionsAmino;
    fromAminoMsg(object: ExecutionConditionsAminoMsg): ExecutionConditions;
    fromProtoMsg(message: ExecutionConditionsProtoMsg): ExecutionConditions;
    toProto(message: ExecutionConditions): Uint8Array;
    toProtoMsg(message: ExecutionConditions): ExecutionConditionsProtoMsg;
};
export declare const FeedbackLoop: {
    typeUrl: string;
    is(o: any): o is FeedbackLoop;
    isSDK(o: any): o is FeedbackLoopSDKType;
    isAmino(o: any): o is FeedbackLoopAmino;
    encode(message: FeedbackLoop, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): FeedbackLoop;
    fromJSON(object: any): FeedbackLoop;
    toJSON(message: FeedbackLoop): JsonSafe<FeedbackLoop>;
    fromPartial(object: Partial<FeedbackLoop>): FeedbackLoop;
    fromAmino(object: FeedbackLoopAmino): FeedbackLoop;
    toAmino(message: FeedbackLoop): FeedbackLoopAmino;
    fromAminoMsg(object: FeedbackLoopAminoMsg): FeedbackLoop;
    fromProtoMsg(message: FeedbackLoopProtoMsg): FeedbackLoop;
    toProto(message: FeedbackLoop): Uint8Array;
    toProtoMsg(message: FeedbackLoop): FeedbackLoopProtoMsg;
};
export declare const Comparison: {
    typeUrl: string;
    is(o: any): o is Comparison;
    isSDK(o: any): o is ComparisonSDKType;
    isAmino(o: any): o is ComparisonAmino;
    encode(message: Comparison, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Comparison;
    fromJSON(object: any): Comparison;
    toJSON(message: Comparison): JsonSafe<Comparison>;
    fromPartial(object: Partial<Comparison>): Comparison;
    fromAmino(object: ComparisonAmino): Comparison;
    toAmino(message: Comparison): ComparisonAmino;
    fromAminoMsg(object: ComparisonAminoMsg): Comparison;
    fromProtoMsg(message: ComparisonProtoMsg): Comparison;
    toProto(message: Comparison): Uint8Array;
    toProtoMsg(message: Comparison): ComparisonProtoMsg;
};
export declare const ICQConfig: {
    typeUrl: string;
    is(o: any): o is ICQConfig;
    isSDK(o: any): o is ICQConfigSDKType;
    isAmino(o: any): o is ICQConfigAmino;
    encode(message: ICQConfig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ICQConfig;
    fromJSON(object: any): ICQConfig;
    toJSON(message: ICQConfig): JsonSafe<ICQConfig>;
    fromPartial(object: Partial<ICQConfig>): ICQConfig;
    fromAmino(object: ICQConfigAmino): ICQConfig;
    toAmino(message: ICQConfig): ICQConfigAmino;
    fromAminoMsg(object: ICQConfigAminoMsg): ICQConfig;
    fromProtoMsg(message: ICQConfigProtoMsg): ICQConfig;
    toProto(message: ICQConfig): Uint8Array;
    toProtoMsg(message: ICQConfig): ICQConfigProtoMsg;
};