import { DeepPartial as DeepPartial$2, DBResponse, TemplateInstance, TimeseriesResult as TimeseriesResult$1, ProcessStreamResponse, DBRequest_DBUpsert, ProcessStreamResponseV3, DBRequest, HandlerType as HandlerType$1, ProcessConfigResponse, StartRequest, DataBinding as DataBinding$1, PreparedData, ProcessResult as ProcessResult$1, PreprocessResult, ProcessStreamResponse_Partitions, UpdateTemplatesRequest } from '@sentio/protos';
import { Subject } from 'rxjs';
import { AsyncLocalStorage } from 'node:async_hooks';
import _m0 from 'protobufjs/minimal.js';

type Request = Omit<DBRequest, 'opId'>;
type RequestType = keyof Request;
declare const timeoutError: Error;
interface IStoreContext {
    sendRequest(request: DeepPartial$2<Request>, timeoutSecs?: number): Promise<DBResponse>;
    result(dbResult: DBResponse): void;
    error(processId: number, e: any): void;
    close(): void;
}
interface IDataBindingContext extends IStoreContext {
    sendTemplateRequest(templates: Array<TemplateInstance>): void;
    sendTimeseriesRequest(timeseries: Array<TimeseriesResult$1>): void;
}
declare abstract class AbstractStoreContext implements IStoreContext {
    readonly processId: number;
    private static opCounter;
    protected defers: Map<bigint, {
        resolve: (value: any) => void;
        reject: (reason?: any) => void;
        requestType?: RequestType;
    }>;
    private statsInterval;
    private pendings;
    constructor(processId: number);
    newPromise<T>(opId: bigint, requestType?: RequestType): Promise<T>;
    abstract doSend(resp: DeepPartial$2<ProcessStreamResponse>): void;
    sendRequest(request: DeepPartial$2<Request>, timeoutSecs?: number): Promise<DBResponse>;
    result(dbResult: DBResponse): void;
    error(processId: number, e: any): void;
    close(): void;
    upsertBatch: {
        opId: bigint;
        request: DBRequest_DBUpsert;
        promise: Promise<DBResponse>;
        timer: NodeJS.Timeout;
    } | undefined;
    private sendUpsertInBatch;
    private sendBatch;
    awaitPendings(): Promise<void>;
}
declare class StoreContext extends AbstractStoreContext {
    readonly subject: Subject<DeepPartial$2<ProcessStreamResponse>>;
    constructor(subject: Subject<DeepPartial$2<ProcessStreamResponse>>, processId: number);
    doSend(resp: DeepPartial$2<ProcessStreamResponse>): void;
}
declare class DataBindingContext extends AbstractStoreContext implements IDataBindingContext {
    readonly processId: number;
    readonly subject: Subject<DeepPartial$2<ProcessStreamResponseV3>>;
    constructor(processId: number, subject: Subject<DeepPartial$2<ProcessStreamResponseV3>>);
    sendTemplateRequest(templates: Array<TemplateInstance>): void;
    sendTimeseriesRequest(timeseries: Array<TimeseriesResult$1>): void;
    doSend(resp: DeepPartial$2<ProcessStreamResponseV3>): void;
}

declare abstract class Plugin {
    name: string;
    supportedHandlers: HandlerType$1[];
    configure(config: ProcessConfigResponse, forChainId?: string): Promise<void>;
    start(start: StartRequest): Promise<void>;
    /**
     * @deprecated The method should not be used, use ctx.states instead
     */
    stateDiff(config: ProcessConfigResponse): boolean;
    processBinding(request: DataBinding$1, preparedData: PreparedData | undefined): Promise<ProcessResult$1>;
    preprocessBinding(request: DataBinding$1, preprocessStore: {
        [k: string]: any;
    }): Promise<PreprocessResult>;
    partition(request: DataBinding$1): Promise<ProcessStreamResponse_Partitions>;
    /**
     * method used by action server only
     * @param port
     */
    startServer(port?: number): Promise<void>;
    /**
     * method used by action server only
     */
    shutdownServer(): void;
}
declare class PluginManager {
    static INSTANCE: PluginManager;
    dbContextLocalStorage: AsyncLocalStorage<IStoreContext | undefined>;
    plugins: Plugin[];
    typesToPlugin: Map<HandlerType$1, Plugin>;
    register(plugin: Plugin): void;
    configure(config: ProcessConfigResponse): Promise<void>;
    start(start: StartRequest, actionServerPort?: number): Promise<void[]>;
    startServer(port?: number): Promise<void[]>;
    shutdown(): void;
    /**
     * @deprecated The method should not be used, use ctx.states instead
     */
    stateDiff(config: ProcessConfigResponse): boolean;
    processBinding(request: DataBinding$1, preparedData: PreparedData | undefined, dbContext?: IStoreContext): Promise<ProcessResult$1>;
    partition(request: DataBinding$1): Promise<ProcessStreamResponse_Partitions>;
    preprocessBinding(request: DataBinding$1, preprocessStore: {
        [k: string]: any;
    }, dbContext?: StoreContext): Promise<PreprocessResult>;
    updateTemplates(request: UpdateTemplatesRequest): Promise<void>;
}

declare enum RichValue_NullValue {
    NULL_VALUE = 0,
    UNRECOGNIZED = -1
}
interface Duration {
    value: number;
    unit: string;
}
declare const Duration: {
    encode(message: Duration, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Duration;
    fromJSON(object: any): Duration;
    toJSON(message: Duration): unknown;
    create(base?: DeepPartial$1<Duration>): Duration;
    fromPartial(object: DeepPartial$1<Duration>): Duration;
};
interface Argument {
    stringValue?: string | undefined;
    intValue?: number | undefined;
    doubleValue?: number | undefined;
    boolValue?: boolean | undefined;
    durationValue?: Duration | undefined;
}
declare const Argument: {
    encode(message: Argument, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Argument;
    fromJSON(object: any): Argument;
    toJSON(message: Argument): unknown;
    create(base?: DeepPartial$1<Argument>): Argument;
    fromPartial(object: DeepPartial$1<Argument>): Argument;
};
interface Function$1 {
    name: string;
    arguments: Argument[];
}
declare const Function$1: {
    encode(message: Function$1, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Function$1;
    fromJSON(object: any): Function$1;
    toJSON(message: Function$1): unknown;
    create(base?: DeepPartial$1<Function$1>): Function$1;
    fromPartial(object: DeepPartial$1<Function$1>): Function$1;
};
interface CoinID {
    symbol?: string | undefined;
    address?: CoinID_AddressIdentifier | undefined;
}
declare const CoinID: {
    encode(message: CoinID, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CoinID;
    fromJSON(object: any): CoinID;
    toJSON(message: CoinID): unknown;
    create(base?: DeepPartial$1<CoinID>): CoinID;
    fromPartial(object: DeepPartial$1<CoinID>): CoinID;
};
interface CoinID_AddressIdentifier {
    address: string;
    chain: string;
}
declare const CoinID_AddressIdentifier: {
    encode(message: CoinID_AddressIdentifier, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CoinID_AddressIdentifier;
    fromJSON(object: any): CoinID_AddressIdentifier;
    toJSON(message: CoinID_AddressIdentifier): unknown;
    create(base?: DeepPartial$1<CoinID_AddressIdentifier>): CoinID_AddressIdentifier;
    fromPartial(object: DeepPartial$1<CoinID_AddressIdentifier>): CoinID_AddressIdentifier;
};
interface RichValue {
    nullValue?: RichValue_NullValue | undefined;
    intValue?: number | undefined;
    int64Value?: bigint | undefined;
    floatValue?: number | undefined;
    bytesValue?: Uint8Array | undefined;
    boolValue?: boolean | undefined;
    stringValue?: string | undefined;
    timestampValue?: Date | undefined;
    bigintValue?: BigInteger | undefined;
    bigdecimalValue?: BigDecimal | undefined;
    listValue?: RichValueList | undefined;
    structValue?: RichStruct | undefined;
    tokenValue?: TokenAmount | undefined;
}
declare const RichValue: {
    encode(message: RichValue, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): RichValue;
    fromJSON(object: any): RichValue;
    toJSON(message: RichValue): unknown;
    create(base?: DeepPartial$1<RichValue>): RichValue;
    fromPartial(object: DeepPartial$1<RichValue>): RichValue;
};
interface RichStruct {
    fields: {
        [key: string]: RichValue;
    };
}
declare const RichStruct: {
    encode(message: RichStruct, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): RichStruct;
    fromJSON(object: any): RichStruct;
    toJSON(message: RichStruct): unknown;
    create(base?: DeepPartial$1<RichStruct>): RichStruct;
    fromPartial(object: DeepPartial$1<RichStruct>): RichStruct;
};
interface RichValueList {
    values: RichValue[];
}
declare const RichValueList: {
    encode(message: RichValueList, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): RichValueList;
    fromJSON(object: any): RichValueList;
    toJSON(message: RichValueList): unknown;
    create(base?: DeepPartial$1<RichValueList>): RichValueList;
    fromPartial(object: DeepPartial$1<RichValueList>): RichValueList;
};
interface BigDecimal {
    value: BigInteger | undefined;
    exp: number;
}
declare const BigDecimal: {
    encode(message: BigDecimal, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): BigDecimal;
    fromJSON(object: any): BigDecimal;
    toJSON(message: BigDecimal): unknown;
    create(base?: DeepPartial$1<BigDecimal>): BigDecimal;
    fromPartial(object: DeepPartial$1<BigDecimal>): BigDecimal;
};
interface BigInteger {
    negative: boolean;
    data: Uint8Array;
}
declare const BigInteger: {
    encode(message: BigInteger, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): BigInteger;
    fromJSON(object: any): BigInteger;
    toJSON(message: BigInteger): unknown;
    create(base?: DeepPartial$1<BigInteger>): BigInteger;
    fromPartial(object: DeepPartial$1<BigInteger>): BigInteger;
};
interface TokenAmount {
    token: CoinID | undefined;
    amount: BigDecimal | undefined;
    specifiedAt: Date | undefined;
}
declare const TokenAmount: {
    encode(message: TokenAmount, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TokenAmount;
    fromJSON(object: any): TokenAmount;
    toJSON(message: TokenAmount): unknown;
    create(base?: DeepPartial$1<TokenAmount>): TokenAmount;
    fromPartial(object: DeepPartial$1<TokenAmount>): TokenAmount;
};
type Builtin$1 = Date | Function$1 | Uint8Array | string | number | boolean | bigint | undefined;
type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial$1<T[K]>;
} : Partial<T>;

declare enum HandlerType {
    UNKNOWN = 0,
    ETH_LOG = 1,
    ETH_BLOCK = 2,
    ETH_TRACE = 5,
    ETH_TRANSACTION = 11,
    SOL_INSTRUCTION = 4,
    APT_EVENT = 6,
    APT_CALL = 7,
    APT_RESOURCE = 8,
    SUI_EVENT = 3,
    SUI_CALL = 9,
    SUI_OBJECT = 10,
    SUI_OBJECT_CHANGE = 12,
    FUEL_CALL = 13,
    FUEL_RECEIPT = 19,
    FUEL_TRANSACTION = 20,
    FUEL_BLOCK = 17,
    COSMOS_CALL = 14,
    STARKNET_EVENT = 15,
    BTC_TRANSACTION = 16,
    BTC_BLOCK = 18,
    UNRECOGNIZED = -1
}
declare enum LogLevel {
    DEBUG = 0,
    INFO = 1,
    WARNING = 2,
    ERROR = 3,
    CRITICAL = 4,
    UNRECOGNIZED = -1
}
declare enum ExecutionConfig_HandlerOrderInsideTransaction {
    BY_LOG_INDEX = 0,
    BY_PROCESSOR_AND_LOG_INDEX = 1,
    UNRECOGNIZED = -1
}
declare enum TimeseriesResult_TimeseriesType {
    EVENT = 0,
    GAUGE = 1,
    COUNTER = 2,
    UNRECOGNIZED = -1
}
interface ExecutionConfig {
    sequential: boolean;
    forceExactBlockTime: boolean;
    handlerOrderInsideTransaction: ExecutionConfig_HandlerOrderInsideTransaction;
    processBindingTimeout: number;
    skipStartBlockValidation: boolean;
    rpcRetryTimes: number;
    ethAbiDecoderConfig?: ExecutionConfig_DecoderWorkerConfig | undefined;
}
declare const ExecutionConfig: {
    encode(message: ExecutionConfig, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ExecutionConfig;
    fromJSON(object: any): ExecutionConfig;
    toJSON(message: ExecutionConfig): unknown;
    create(base?: DeepPartial<ExecutionConfig>): ExecutionConfig;
    fromPartial(object: DeepPartial<ExecutionConfig>): ExecutionConfig;
};
interface ExecutionConfig_DecoderWorkerConfig {
    enabled: boolean;
    workerCount?: number | undefined;
    skipWhenDecodeFailed?: boolean | undefined;
}
declare const ExecutionConfig_DecoderWorkerConfig: {
    encode(message: ExecutionConfig_DecoderWorkerConfig, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ExecutionConfig_DecoderWorkerConfig;
    fromJSON(object: any): ExecutionConfig_DecoderWorkerConfig;
    toJSON(message: ExecutionConfig_DecoderWorkerConfig): unknown;
    create(base?: DeepPartial<ExecutionConfig_DecoderWorkerConfig>): ExecutionConfig_DecoderWorkerConfig;
    fromPartial(object: DeepPartial<ExecutionConfig_DecoderWorkerConfig>): ExecutionConfig_DecoderWorkerConfig;
};
interface Data {
    ethLog?: Data_EthLog | undefined;
    ethBlock?: Data_EthBlock | undefined;
    ethTransaction?: Data_EthTransaction | undefined;
    ethTrace?: Data_EthTrace | undefined;
    solInstruction?: Data_SolInstruction | undefined;
    aptEvent?: Data_AptEvent | undefined;
    aptCall?: Data_AptCall | undefined;
    aptResource?: Data_AptResource | undefined;
    suiEvent?: Data_SuiEvent | undefined;
    suiCall?: Data_SuiCall | undefined;
    suiObject?: Data_SuiObject | undefined;
    suiObjectChange?: Data_SuiObjectChange | undefined;
    fuelLog?: Data_FuelReceipt | undefined;
    /** @deprecated */
    fuelCall?: Data_FuelCall | undefined;
    fuelTransaction?: Data_FuelTransaction | undefined;
    fuelBlock?: Data_FuelBlock | undefined;
    cosmosCall?: Data_CosmosCall | undefined;
    starknetEvents?: Data_StarknetEvent | undefined;
    btcTransaction?: Data_BTCTransaction | undefined;
    btcBlock?: Data_BTCBlock | undefined;
}
declare const Data: {
    encode(message: Data, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data;
    fromJSON(object: any): Data;
    toJSON(message: Data): unknown;
    create(base?: DeepPartial<Data>): Data;
    fromPartial(object: DeepPartial<Data>): Data;
};
interface Data_EthLog {
    log: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
    transaction?: {
        [key: string]: any;
    } | undefined;
    transactionReceipt?: {
        [key: string]: any;
    } | undefined;
    block?: {
        [key: string]: any;
    } | undefined;
    rawLog: string;
    rawTransaction?: string | undefined;
    rawTransactionReceipt?: string | undefined;
    rawBlock?: string | undefined;
}
declare const Data_EthLog: {
    encode(message: Data_EthLog, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_EthLog;
    fromJSON(object: any): Data_EthLog;
    toJSON(message: Data_EthLog): unknown;
    create(base?: DeepPartial<Data_EthLog>): Data_EthLog;
    fromPartial(object: DeepPartial<Data_EthLog>): Data_EthLog;
};
interface Data_EthBlock {
    block: {
        [key: string]: any;
    } | undefined;
}
declare const Data_EthBlock: {
    encode(message: Data_EthBlock, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_EthBlock;
    fromJSON(object: any): Data_EthBlock;
    toJSON(message: Data_EthBlock): unknown;
    create(base?: DeepPartial<Data_EthBlock>): Data_EthBlock;
    fromPartial(object: DeepPartial<Data_EthBlock>): Data_EthBlock;
};
interface Data_EthTransaction {
    transaction: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
    transactionReceipt?: {
        [key: string]: any;
    } | undefined;
    block?: {
        [key: string]: any;
    } | undefined;
    trace?: {
        [key: string]: any;
    } | undefined;
    rawTransaction: string;
    rawTransactionReceipt?: string | undefined;
    rawBlock?: string | undefined;
    rawTrace?: string | undefined;
}
declare const Data_EthTransaction: {
    encode(message: Data_EthTransaction, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_EthTransaction;
    fromJSON(object: any): Data_EthTransaction;
    toJSON(message: Data_EthTransaction): unknown;
    create(base?: DeepPartial<Data_EthTransaction>): Data_EthTransaction;
    fromPartial(object: DeepPartial<Data_EthTransaction>): Data_EthTransaction;
};
interface Data_EthTrace {
    trace: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
    transaction?: {
        [key: string]: any;
    } | undefined;
    transactionReceipt?: {
        [key: string]: any;
    } | undefined;
    block?: {
        [key: string]: any;
    } | undefined;
}
declare const Data_EthTrace: {
    encode(message: Data_EthTrace, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_EthTrace;
    fromJSON(object: any): Data_EthTrace;
    toJSON(message: Data_EthTrace): unknown;
    create(base?: DeepPartial<Data_EthTrace>): Data_EthTrace;
    fromPartial(object: DeepPartial<Data_EthTrace>): Data_EthTrace;
};
interface Data_SolInstruction {
    instructionData: string;
    slot: bigint;
    programAccountId: string;
    accounts: string[];
    parsed?: {
        [key: string]: any;
    } | undefined;
}
declare const Data_SolInstruction: {
    encode(message: Data_SolInstruction, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_SolInstruction;
    fromJSON(object: any): Data_SolInstruction;
    toJSON(message: Data_SolInstruction): unknown;
    create(base?: DeepPartial<Data_SolInstruction>): Data_SolInstruction;
    fromPartial(object: DeepPartial<Data_SolInstruction>): Data_SolInstruction;
};
interface Data_AptEvent {
    rawEvent: string;
    eventIndex: number;
    /** @deprecated */
    transaction: {
        [key: string]: any;
    } | undefined;
    rawTransaction: string;
}
declare const Data_AptEvent: {
    encode(message: Data_AptEvent, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_AptEvent;
    fromJSON(object: any): Data_AptEvent;
    toJSON(message: Data_AptEvent): unknown;
    create(base?: DeepPartial<Data_AptEvent>): Data_AptEvent;
    fromPartial(object: DeepPartial<Data_AptEvent>): Data_AptEvent;
};
interface Data_AptCall {
    /** @deprecated */
    transaction: {
        [key: string]: any;
    } | undefined;
    rawTransaction: string;
}
declare const Data_AptCall: {
    encode(message: Data_AptCall, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_AptCall;
    fromJSON(object: any): Data_AptCall;
    toJSON(message: Data_AptCall): unknown;
    create(base?: DeepPartial<Data_AptCall>): Data_AptCall;
    fromPartial(object: DeepPartial<Data_AptCall>): Data_AptCall;
};
interface Data_AptResource {
    /** @deprecated */
    resources: {
        [key: string]: any;
    }[];
    version: bigint;
    timestampMicros: bigint;
    rawResources: string[];
}
declare const Data_AptResource: {
    encode(message: Data_AptResource, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_AptResource;
    fromJSON(object: any): Data_AptResource;
    toJSON(message: Data_AptResource): unknown;
    create(base?: DeepPartial<Data_AptResource>): Data_AptResource;
    fromPartial(object: DeepPartial<Data_AptResource>): Data_AptResource;
};
interface Data_SuiEvent {
    /** @deprecated */
    transaction: {
        [key: string]: any;
    } | undefined;
    rawEvent: string;
    rawTransaction: string;
    timestamp: Date | undefined;
    slot: bigint;
}
declare const Data_SuiEvent: {
    encode(message: Data_SuiEvent, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_SuiEvent;
    fromJSON(object: any): Data_SuiEvent;
    toJSON(message: Data_SuiEvent): unknown;
    create(base?: DeepPartial<Data_SuiEvent>): Data_SuiEvent;
    fromPartial(object: DeepPartial<Data_SuiEvent>): Data_SuiEvent;
};
interface Data_SuiCall {
    /** @deprecated */
    transaction: {
        [key: string]: any;
    } | undefined;
    rawTransaction: string;
    timestamp: Date | undefined;
    slot: bigint;
}
declare const Data_SuiCall: {
    encode(message: Data_SuiCall, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_SuiCall;
    fromJSON(object: any): Data_SuiCall;
    toJSON(message: Data_SuiCall): unknown;
    create(base?: DeepPartial<Data_SuiCall>): Data_SuiCall;
    fromPartial(object: DeepPartial<Data_SuiCall>): Data_SuiCall;
};
interface Data_SuiObject {
    /** @deprecated */
    objects: {
        [key: string]: any;
    }[];
    /** @deprecated */
    self?: {
        [key: string]: any;
    } | undefined;
    rawObjects: string[];
    rawSelf?: string | undefined;
    objectId: string;
    objectVersion: bigint;
    objectDigest: string;
    timestamp: Date | undefined;
    slot: bigint;
}
declare const Data_SuiObject: {
    encode(message: Data_SuiObject, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_SuiObject;
    fromJSON(object: any): Data_SuiObject;
    toJSON(message: Data_SuiObject): unknown;
    create(base?: DeepPartial<Data_SuiObject>): Data_SuiObject;
    fromPartial(object: DeepPartial<Data_SuiObject>): Data_SuiObject;
};
interface Data_SuiObjectChange {
    /** @deprecated */
    changes: {
        [key: string]: any;
    }[];
    rawChanges: string[];
    timestamp: Date | undefined;
    txDigest: string;
    slot: bigint;
}
declare const Data_SuiObjectChange: {
    encode(message: Data_SuiObjectChange, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_SuiObjectChange;
    fromJSON(object: any): Data_SuiObjectChange;
    toJSON(message: Data_SuiObjectChange): unknown;
    create(base?: DeepPartial<Data_SuiObjectChange>): Data_SuiObjectChange;
    fromPartial(object: DeepPartial<Data_SuiObjectChange>): Data_SuiObjectChange;
};
interface Data_FuelReceipt {
    transaction: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
    receiptIndex: bigint;
}
declare const Data_FuelReceipt: {
    encode(message: Data_FuelReceipt, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_FuelReceipt;
    fromJSON(object: any): Data_FuelReceipt;
    toJSON(message: Data_FuelReceipt): unknown;
    create(base?: DeepPartial<Data_FuelReceipt>): Data_FuelReceipt;
    fromPartial(object: DeepPartial<Data_FuelReceipt>): Data_FuelReceipt;
};
interface Data_FuelTransaction {
    transaction: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_FuelTransaction: {
    encode(message: Data_FuelTransaction, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_FuelTransaction;
    fromJSON(object: any): Data_FuelTransaction;
    toJSON(message: Data_FuelTransaction): unknown;
    create(base?: DeepPartial<Data_FuelTransaction>): Data_FuelTransaction;
    fromPartial(object: DeepPartial<Data_FuelTransaction>): Data_FuelTransaction;
};
/** @deprecated */
interface Data_FuelCall {
    transaction: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_FuelCall: {
    encode(message: Data_FuelCall, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_FuelCall;
    fromJSON(object: any): Data_FuelCall;
    toJSON(message: Data_FuelCall): unknown;
    create(base?: DeepPartial<Data_FuelCall>): Data_FuelCall;
    fromPartial(object: DeepPartial<Data_FuelCall>): Data_FuelCall;
};
interface Data_FuelBlock {
    block: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_FuelBlock: {
    encode(message: Data_FuelBlock, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_FuelBlock;
    fromJSON(object: any): Data_FuelBlock;
    toJSON(message: Data_FuelBlock): unknown;
    create(base?: DeepPartial<Data_FuelBlock>): Data_FuelBlock;
    fromPartial(object: DeepPartial<Data_FuelBlock>): Data_FuelBlock;
};
interface Data_CosmosCall {
    transaction: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_CosmosCall: {
    encode(message: Data_CosmosCall, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_CosmosCall;
    fromJSON(object: any): Data_CosmosCall;
    toJSON(message: Data_CosmosCall): unknown;
    create(base?: DeepPartial<Data_CosmosCall>): Data_CosmosCall;
    fromPartial(object: DeepPartial<Data_CosmosCall>): Data_CosmosCall;
};
interface Data_StarknetEvent {
    result: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_StarknetEvent: {
    encode(message: Data_StarknetEvent, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_StarknetEvent;
    fromJSON(object: any): Data_StarknetEvent;
    toJSON(message: Data_StarknetEvent): unknown;
    create(base?: DeepPartial<Data_StarknetEvent>): Data_StarknetEvent;
    fromPartial(object: DeepPartial<Data_StarknetEvent>): Data_StarknetEvent;
};
interface Data_BTCTransaction {
    transaction: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_BTCTransaction: {
    encode(message: Data_BTCTransaction, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_BTCTransaction;
    fromJSON(object: any): Data_BTCTransaction;
    toJSON(message: Data_BTCTransaction): unknown;
    create(base?: DeepPartial<Data_BTCTransaction>): Data_BTCTransaction;
    fromPartial(object: DeepPartial<Data_BTCTransaction>): Data_BTCTransaction;
};
interface Data_BTCBlock {
    block: {
        [key: string]: any;
    } | undefined;
    timestamp: Date | undefined;
}
declare const Data_BTCBlock: {
    encode(message: Data_BTCBlock, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Data_BTCBlock;
    fromJSON(object: any): Data_BTCBlock;
    toJSON(message: Data_BTCBlock): unknown;
    create(base?: DeepPartial<Data_BTCBlock>): Data_BTCBlock;
    fromPartial(object: DeepPartial<Data_BTCBlock>): Data_BTCBlock;
};
interface DataBinding {
    data: Data | undefined;
    handlerType: HandlerType;
    handlerIds: number[];
    chainId: string;
}
declare const DataBinding: {
    encode(message: DataBinding, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DataBinding;
    fromJSON(object: any): DataBinding;
    toJSON(message: DataBinding): unknown;
    create(base?: DeepPartial<DataBinding>): DataBinding;
    fromPartial(object: DeepPartial<DataBinding>): DataBinding;
};
interface StateResult {
    configUpdated: boolean;
    error?: string | undefined;
}
declare const StateResult: {
    encode(message: StateResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): StateResult;
    fromJSON(object: any): StateResult;
    toJSON(message: StateResult): unknown;
    create(base?: DeepPartial<StateResult>): StateResult;
    fromPartial(object: DeepPartial<StateResult>): StateResult;
};
interface ProcessResult {
    gauges: GaugeResult[];
    counters: CounterResult[];
    events: EventTrackingResult[];
    exports: ExportResult[];
    states: StateResult | undefined;
    timeseriesResult: TimeseriesResult[];
}
declare const ProcessResult: {
    encode(message: ProcessResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ProcessResult;
    fromJSON(object: any): ProcessResult;
    toJSON(message: ProcessResult): unknown;
    create(base?: DeepPartial<ProcessResult>): ProcessResult;
    fromPartial(object: DeepPartial<ProcessResult>): ProcessResult;
};
interface RecordMetaData {
    address: string;
    contractName: string;
    blockNumber: bigint;
    transactionHash: string;
    chainId: string;
    transactionIndex: number;
    logIndex: number;
    name: string;
    labels: {
        [key: string]: string;
    };
}
declare const RecordMetaData: {
    encode(message: RecordMetaData, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): RecordMetaData;
    fromJSON(object: any): RecordMetaData;
    toJSON(message: RecordMetaData): unknown;
    create(base?: DeepPartial<RecordMetaData>): RecordMetaData;
    fromPartial(object: DeepPartial<RecordMetaData>): RecordMetaData;
};
interface MetricValue {
    bigDecimal?: string | undefined;
    doubleValue?: number | undefined;
    bigInteger?: BigInteger | undefined;
}
declare const MetricValue: {
    encode(message: MetricValue, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MetricValue;
    fromJSON(object: any): MetricValue;
    toJSON(message: MetricValue): unknown;
    create(base?: DeepPartial<MetricValue>): MetricValue;
    fromPartial(object: DeepPartial<MetricValue>): MetricValue;
};
interface RuntimeInfo {
    from: HandlerType;
}
declare const RuntimeInfo: {
    encode(message: RuntimeInfo, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): RuntimeInfo;
    fromJSON(object: any): RuntimeInfo;
    toJSON(message: RuntimeInfo): unknown;
    create(base?: DeepPartial<RuntimeInfo>): RuntimeInfo;
    fromPartial(object: DeepPartial<RuntimeInfo>): RuntimeInfo;
};
interface GaugeResult {
    metadata: RecordMetaData | undefined;
    metricValue: MetricValue | undefined;
    runtimeInfo: RuntimeInfo | undefined;
}
declare const GaugeResult: {
    encode(message: GaugeResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GaugeResult;
    fromJSON(object: any): GaugeResult;
    toJSON(message: GaugeResult): unknown;
    create(base?: DeepPartial<GaugeResult>): GaugeResult;
    fromPartial(object: DeepPartial<GaugeResult>): GaugeResult;
};
interface CounterResult {
    metadata: RecordMetaData | undefined;
    metricValue: MetricValue | undefined;
    add: boolean;
    runtimeInfo: RuntimeInfo | undefined;
}
declare const CounterResult: {
    encode(message: CounterResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CounterResult;
    fromJSON(object: any): CounterResult;
    toJSON(message: CounterResult): unknown;
    create(base?: DeepPartial<CounterResult>): CounterResult;
    fromPartial(object: DeepPartial<CounterResult>): CounterResult;
};
interface EventTrackingResult {
    metadata: RecordMetaData | undefined;
    distinctEntityId: string;
    attributes: {
        [key: string]: any;
    } | undefined;
    severity: LogLevel;
    message: string;
    runtimeInfo: RuntimeInfo | undefined;
    attributes2: RichStruct | undefined;
    noMetric: boolean;
}
declare const EventTrackingResult: {
    encode(message: EventTrackingResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): EventTrackingResult;
    fromJSON(object: any): EventTrackingResult;
    toJSON(message: EventTrackingResult): unknown;
    create(base?: DeepPartial<EventTrackingResult>): EventTrackingResult;
    fromPartial(object: DeepPartial<EventTrackingResult>): EventTrackingResult;
};
interface TimeseriesResult {
    metadata: RecordMetaData | undefined;
    type: TimeseriesResult_TimeseriesType;
    data: RichStruct | undefined;
    runtimeInfo: RuntimeInfo | undefined;
}
declare const TimeseriesResult: {
    encode(message: TimeseriesResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TimeseriesResult;
    fromJSON(object: any): TimeseriesResult;
    toJSON(message: TimeseriesResult): unknown;
    create(base?: DeepPartial<TimeseriesResult>): TimeseriesResult;
    fromPartial(object: DeepPartial<TimeseriesResult>): TimeseriesResult;
};
interface ExportResult {
    metadata: RecordMetaData | undefined;
    payload: string;
    runtimeInfo: RuntimeInfo | undefined;
}
declare const ExportResult: {
    encode(message: ExportResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ExportResult;
    fromJSON(object: any): ExportResult;
    toJSON(message: ExportResult): unknown;
    create(base?: DeepPartial<ExportResult>): ExportResult;
    fromPartial(object: DeepPartial<ExportResult>): ExportResult;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;

export { AbstractStoreContext as A, DataBinding as D, ExecutionConfig as E, HandlerType as H, type IStoreContext as I, Plugin as P, StoreContext as S, ProcessResult as a, PluginManager as b, type IDataBindingContext as c, DataBindingContext as d, timeoutError as t };
