@gbozee/ultimate 0.0.2-7 → 0.0.2-71

package/dist/index.d.ts

@@ -2,9 +2,156 @@
 
 import { HttpsProxyAgent } from 'https-proxy-agent';
 import PocketBase from 'pocketbase';
-import { RecordModel } from 'pocketbase';
+import { RecordModel as PocketBaseRecordModel } from 'pocketbase';
 import { SocksProxyAgent } from 'socks-proxy-agent';
 
+export type RecordModel = PocketBaseRecordModel;
+export interface BaseSystemFields {
+	id: string;
+	created: string;
+	updated: string;
+}
+export interface ExchangeAccount extends BaseSystemFields {
+	exchange: "binance" | "bybit";
+	owner: string;
+	email?: string;
+	user?: string;
+	usdt?: number;
+	usdc?: number;
+	proxy?: string;
+	bullish?: boolean;
+	bearish?: boolean;
+	movePercent?: number;
+	totalRisk?: number;
+	max_non_essential?: number;
+	profit_percent?: number;
+	risk_reward?: number;
+	exclude_coins?: {
+		bullish?: string[];
+	};
+	include_delisted?: boolean;
+}
+export interface Order extends BaseSystemFields {
+	symbol: string;
+	account: string;
+	kind: "long" | "short";
+	price: number;
+	quantity: number;
+	side: "sell" | "buy";
+	stop: number;
+	order_id: string;
+}
+export interface SymbolConfig extends BaseSystemFields {
+	symbol: string;
+	support?: number;
+	resistance?: number;
+	stop_percent?: number;
+	price_places?: string;
+	decimal_places?: string;
+	min_size?: number;
+	weight?: number;
+	leverage?: number;
+	candle_count?: number;
+	interval?: any;
+	fee_percent?: number;
+}
+export interface ScheduledTrade extends BaseSystemFields {
+	symbol: string;
+	account: string;
+	profit?: number;
+	risk?: number;
+	entry?: number;
+	stop?: number;
+	risk_reward?: number;
+	profit_percent?: number;
+	place_tp?: boolean;
+	kind?: "long" | "short";
+	follow?: boolean | 1 | 0;
+	reduce_ratio?: number;
+	sell_ratio?: number;
+	threshold_qty?: number;
+	pause_tp?: boolean;
+}
+export interface AccountStrategy extends BaseSystemFields {
+	account: string;
+	symbol: string;
+	tp_percent: number;
+	short_tp_factor: number;
+	fee_percent: number;
+	budget: number;
+	risk_reward: number;
+	reduce_ratio: number;
+}
+interface Proxy$1 extends BaseSystemFields {
+	ip_address?: string;
+	type?: "http" | "socks5";
+}
+export interface TradeBlockTracking extends BaseSystemFields {
+	account?: string;
+	symbol?: string;
+	running?: boolean;
+}
+export interface PositionsView {
+	id: string;
+	symbol?: any;
+	entry?: any;
+	quantity?: any;
+	take_profit?: any;
+	account?: any;
+	kind?: any;
+	target_pnl?: number;
+	liquidation?: number;
+	avg_price?: number;
+	avg_qty?: number;
+	next_order?: number;
+	last_order?: number;
+	config?: any;
+	stop_loss?: {
+		price: number;
+		quantity: number;
+	};
+	stop_pnl?: any;
+	leverage?: any;
+	avg_liquidation?: any;
+	balance?: any;
+	reduce_ratio?: number;
+	sell_ratio?: number;
+	threshold_qty?: number;
+	follow?: boolean | 1 | 0;
+	current_price?: number;
+	usd_balance?: number;
+}
+export interface BullishMarket extends RecordModel {
+	id: string;
+	symbol: string;
+	risk: number;
+}
+export interface WindingDownMarket extends RecordModel {
+	id: string;
+	symbol: string;
+	risk_reward: number;
+}
+export type GlobalConfig = {
+	profit_percent: number;
+	symbol: string;
+	profit: number;
+	risk: number;
+	stop_percent: number;
+	kind: "long" | "short";
+	reduce_percent: number;
+	support: number;
+	resistance: number;
+	price_places: string;
+	decimal_places: string;
+	min_size: number;
+	accounts: {
+		owner: string;
+		exchange?: string;
+	}[];
+	risk_reward: number;
+	reverse_factor: number;
+	leverage?: number;
+};
 interface Position$1 {
 	id: number;
 	kind: "long" | "short";
@@ -85,10 +232,15 @@ export interface BaseExchange {
 		count: number;
 		raw?: boolean;
 	}): Promise<any>;
-	getExchangeAccountInfo(account: {
-		owner: string;
-		exchange: string;
-	}, symbol: string): Promise<any>;
+	getExchangeAccountInfo(options: {
+		price_places?: string;
+		decimal_places?: string;
+		account: {
+			owner: string;
+			exchange: string;
+		};
+		symbol: string;
+	}): Promise<any>;
 	cancelOrders(payload: {
 		symbol: string;
 		orders: number[];
@@ -98,6 +250,7 @@ export interface BaseExchange {
 		take_profit: number;
 		kind: "long" | "short";
 		cancel?: boolean;
+		quantity?: number;
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
@@ -121,122 +274,107 @@ export interface BaseExchange {
 		symbol: string;
 		leverage: number;
 	}): Promise<any>;
-}
-export interface BaseSystemFields {
-	id: string;
-	created: string;
-	updated: string;
-}
-export interface ExchangeAccount extends BaseSystemFields {
-	exchange: "binance" | "bybit";
-	owner: string;
-	email?: string;
-	user?: string;
-	usdt?: number;
-	usdc?: number;
-	proxy?: string;
-}
-export interface SymbolConfig extends BaseSystemFields {
-	symbol: string;
-	support?: number;
-	resistance?: number;
-	stop_percent?: number;
-	price_places?: string;
-	decimal_places?: string;
-	min_size?: number;
-	weight?: number;
-	leverage?: number;
-}
-export interface ScheduledTrade extends BaseSystemFields {
-	symbol: string;
-	account: string;
-	profit?: number;
-	risk?: number;
-	entry?: number;
-	stop?: number;
-	risk_reward?: number;
-	profit_percent?: number;
-	place_tp?: boolean;
-	kind?: "long" | "short";
-	current_price?: number;
-}
-export interface Strategy extends BaseSystemFields {
-	name: string;
-	short_risk_factor?: number;
-	long_risk_factor?: number;
-	profit_percent?: number;
-	cancel_short?: boolean;
-	cancel_long?: boolean;
-	recompute_short_config?: boolean;
-	update_stop_loss?: boolean;
-	liquidation_as_entry?: boolean;
-	stop_as_entry?: boolean;
-	tp_as_stop?: boolean;
-	entry_as_stop?: boolean;
-	place_stop?: boolean;
-	save_config?: boolean;
-}
-interface Proxy$1 extends BaseSystemFields {
-	ip_address?: string;
-	type?: "http" | "socks5";
-}
-export interface TradeBlockTracking extends BaseSystemFields {
-	account?: string;
-	symbol?: string;
-	running?: boolean;
-}
-export interface PositionsView {
-	id: string;
-	symbol?: any;
-	entry?: any;
-	quantity?: any;
-	take_profit?: any;
-	account?: any;
-	kind?: any;
-	target_pnl?: number;
-	liquidation?: number;
-	avg_price?: number;
-	avg_qty?: number;
-	next_order?: number;
-	last_order?: number;
-	config?: any;
-	stop_loss?: {
-		price: number;
+	generateConfig(payload: {
+		symbol: string;
+		interval?: any;
+		limit?: number;
+	}): Promise<any>;
+	checkDelistedMovers(payload: {
+		movePercent: number;
+		include_delisted?: boolean;
+	}): Promise<any>;
+	closePosition(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		price_places?: string;
+		decimal_places?: string;
+	}): Promise<any>;
+	getAllOpenSymbols(): Promise<string[]>;
+	createLimitPurchaseOrders(payload: {
+		orders: any[];
+		kind: "long" | "short";
+		decimal_places?: string;
+		price_places?: string;
+		symbol: string;
+	}): Promise<any>;
+	getDelistedSpotSymbols(): Promise<any>;
+	getOpenPositions(): Promise<any>;
+	crossAccountTransfer(payload: {
+		from: {
+			owner: string;
+			wallet: string;
+		};
+		to: {
+			owner: string;
+			wallet: string;
+		};
+		asset: string;
+		amount: number;
+	}): Promise<any>;
+	placeMarketOrder(payload: {
+		symbol: string;
+		kind: "long" | "short";
 		quantity: number;
-	};
-	stop_pnl?: any;
-	leverage?: any;
-	avg_liquidation?: any;
-	balance?: any;
-}
-export interface BullishMarket extends RecordModel {
-	id: string;
-	symbol: string;
-	risk: number;
-}
-export interface WindingDownMarket extends RecordModel {
-	id: string;
-	symbol: string;
+		price_places?: string;
+		decimal_places?: string;
+	}): Promise<any>;
 }
+declare function initPocketBaseClient(proxy_credentials: {
+	host: string;
+	email: string;
+	password: string;
+	auto_cancellation?: boolean;
+}): Promise<PocketBase>;
 export type ExchangeType = {
 	owner: string;
 	exchange: string;
 };
 export declare class AppDatabase {
-	private pb;
+	pb: PocketBase;
 	constructor(pb: PocketBase);
+	getCredentials(password: string): any;
+	saveCredentials(password: string, credentials: any): Promise<void>;
+	addNewCredential(password: string, payload: {
+		name: string;
+		exchange: string;
+		api_key: string;
+		api_secret: string;
+	}): Promise<void>;
+	getAllSymbolsFromPositions(options?: {
+		no_position?: boolean;
+		kind?: "long" | "short";
+		custom_filter?: string;
+	}): Promise<any[]>;
+	createOrUpdateLiveExchangeInstance(payload: {
+		account: ExchangeType;
+		symbol: string;
+		data?: any;
+	}): Promise<import("pocketbase").RecordModel>;
+	getLiveExchangeInstance(payload: {
+		account: ExchangeType;
+		symbol: string;
+		data?: any;
+	}): Promise<import("pocketbase").RecordModel>;
 	getProxyForAccount(account: ExchangeType): Promise<HttpsProxyAgent<`http://${string}`> | SocksProxyAgent>;
+	getAccounts(): Promise<ExchangeAccount[]>;
+	getAllSymbolConfigs(payload?: {
+		with_positions?: boolean;
+		custom_filter?: string;
+	}): Promise<SymbolConfig[]>;
 	get_exchange_db_instance(account: ExchangeType): Promise<ExchangeAccount & {
 		expand?: {
 			proxy: Proxy$1;
 		};
 	}>;
-	getPositions(account: ExchangeType, options: {
-		symbol: string;
+	getPositions(options: {
+		account?: ExchangeType;
+		symbol?: string;
 		as_view?: boolean;
+		custom_filter?: string;
 	}): Promise<(PositionsView & {
 		expand?: {
 			config: ScheduledTrade;
+			account: ExchangeAccount;
 		};
 	})[]>;
 	private _createOrUpdatePosition;
@@ -248,6 +386,7 @@ export declare class AppDatabase {
 	}): Promise<(PositionsView & {
 		expand?: {
 			config: ScheduledTrade;
+			account: ExchangeAccount;
 		};
 	})[]>;
 	update_db_position(position: any, payload: any): Promise<import("pocketbase").RecordModel>;
@@ -259,7 +398,7 @@ export declare class AppDatabase {
 	getOrders(account: ExchangeType, options: {
 		symbol: string;
 		kind: "long" | "short";
-	}): Promise<import("pocketbase").RecordModel[]>;
+	}): Promise<Order[]>;
 	deleteAndRecreateOrders(account: ExchangeType, options: {
 		symbol: string;
 		kind: "long" | "short";
@@ -272,7 +411,32 @@ export declare class AppDatabase {
 		stop: number;
 		order_id: string;
 		triggerPrice?: number;
-	}>): Promise<import("pocketbase").RecordModel[]>;
+	}>): Promise<Order[]>;
+	deleteAndBulCreateAllOrders(payload: {
+		account: ExchangeType & {
+			id: string;
+		};
+		symbol: string;
+		all_orders: Array<{
+			symbol: string;
+			price: number;
+			quantity: number;
+			kind: "long" | "short";
+			side: "buy" | "sell";
+			stop: number;
+			order_id: string;
+			triggerPrice?: number;
+		}>;
+	}): Promise<void>;
+	cancelLimitOrders(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		account: ExchangeType;
+		cancelExchangeOrders: (payload: {
+			symbol: string;
+			orders: number[];
+		}) => Promise<any>;
+	}): Promise<void>;
 	cancelOrders(payload: {
 		cancelExchangeOrders: (payload: {
 			symbol: string;
@@ -300,30 +464,41 @@ export declare class AppDatabase {
 		message?: undefined;
 		exchange_result?: undefined;
 	}>;
+	getMoverExchangeInstances(): Promise<ExchangeAccount[]>;
+	updateScheduledTrade(id: string, payload: any): Promise<import("pocketbase").RecordModel>;
+	getPositionsToAutoFollow(): Promise<(Position$1 & {
+		expand: {
+			account: ExchangeAccount;
+		};
+	})[]>;
 	createOrUpdatePositionConfig(db_position: any, payload: {
 		entry: number;
 		stop: number;
 		risk_reward: number;
 		risk: number;
 		profit_percent?: number;
-	}): Promise<void>;
+		place_tp?: boolean;
+		profit?: number;
+	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
 	getPositionConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		account: ExchangeType;
+	}): Promise<ScheduledTrade | null>;
+	getPositionStrategy(account: ExchangeType): Promise<AccountStrategy>;
+	createOrUpdateWindingDownMarket(payload: {
+		symbol: string;
+		risk_reward?: number;
 	}): Promise<import("pocketbase").RecordModel>;
-	getPositionStrategy(account: ExchangeType): Promise<{
-		strategy_instance: Strategy;
-		focus_account: ExchangeAccount;
-	}>;
-	createOrUpdateWindingDownMarket(symbol: string): Promise<import("pocketbase").RecordModel>;
-	getWindingDownMarkets(): Promise<WindingDownMarket[]>;
+	getWindingDownMarkets(symbol?: string): Promise<WindingDownMarket[]>;
+	getBullishMarket(symbol: string): Promise<BullishMarket>;
 	getBullishMarkets(options?: {
 		new_markets: Array<{
 			symbol: string;
 			percent: number;
 		}>;
 		totalRisk: number;
+		max_count?: number;
 	}): Promise<{
 		updated_bullish: BullishMarket[];
 		moved_to_winding: WindingDownMarket[];
@@ -342,18 +517,293 @@ export declare class AppDatabase {
 		updated: number;
 		created: number;
 	} | SymbolConfig[]>;
-	unwindSymbolFromDB(symbol: string): Promise<void>;
+	unwindSymbolFromDB(symbol: string): Promise<boolean>;
+	hasExistingPosition(symbol: string): Promise<import("pocketbase").RecordModel[]>;
+	hasExistingOrders(symbol: string): Promise<import("pocketbase").RecordModel[]>;
+	removeSymbolFromUnwindingMarkets(symbol: string): Promise<boolean>;
+	removePosition(position: any): Promise<void>;
+	removePositionConfig(position: any): Promise<void>;
+}
+export type StrategyPosition = {
+	entry: number;
+	quantity: number;
+};
+export type Config = {
+	tp_percent: number;
+	short_tp_factor: number;
+	fee_percent?: number;
+	budget: number;
+	risk_reward: number;
+	reduce_ratio: number;
+	global_config: GlobalConfig;
+};
+export declare class Strategy {
+	position: {
+		long: StrategyPosition;
+		short: StrategyPosition;
+	};
+	dominant_position?: "long" | "short";
+	config: Config;
+	constructor(payload: {
+		long: StrategyPosition;
+		short: StrategyPosition;
+		config: Config;
+		dominant_position?: "long" | "short";
+	});
+	get price_places(): string;
+	get decimal_places(): string;
+	to_f(price: number): number;
+	to_df(quantity: number): number;
+	pnl(kind: "long" | "short", _position?: StrategyPosition): number;
+	tp(kind: "long" | "short"): number;
+	calculate_fee(position: {
+		price: number;
+		quantity: number;
+	}): number;
+	get long_tp(): number;
+	get short_tp(): number;
+	generateGapClosingAlgorithm(payload: {
+		kind: "long" | "short";
+	}): {
+		[x: string]: any;
+		risk: number;
+		risk_reward: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	};
+	runIterations(payload: {
+		kind: "long" | "short";
+		iterations: number;
+		risk_reward?: number;
+	}): {
+		[x: string]: any;
+		risk: number;
+		risk_reward: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	}[];
+	getPositionAfterTp(payload: {
+		kind: "long" | "short";
+		include_fees?: boolean;
+	}): {
+		[x: string]: number | {
+			entry: number;
+			quantity: number;
+			diff?: undefined;
+		} | {
+			[x: string]: number;
+			diff: number;
+			entry?: undefined;
+			quantity?: undefined;
+		};
+		pnl: {
+			[x: string]: number;
+			diff: number;
+		};
+		spread: number;
+	};
+	getPositionAfterIteration(payload: {
+		kind: "long" | "short";
+		iterations: number;
+		with_fees?: boolean;
+	}): {
+		[x: string]: number | {
+			entry: number;
+			quantity: number;
+			diff?: undefined;
+		} | {
+			[x: string]: number;
+			diff: number;
+			entry?: undefined;
+			quantity?: undefined;
+		};
+		pnl: {
+			[x: string]: number;
+			diff: number;
+		};
+		spread: number;
+	}[];
+	/**To be used as one of the agent tools eventually since
+	 * it is something that can be triggered continously without
+	 * any risk
+	 */
+	generateOppositeTrades(payload: {
+		kind: "long" | "short";
+		risk_factor?: number;
+	}): {
+		avg: {
+			entry: number;
+			price: number;
+			quantity: number;
+		};
+		loss: number;
+		profit_percent: number;
+		fee: number;
+		risk_per_trade: number;
+		risk_reward: number;
+		symbol?: string;
+		focus: number;
+		budget: number;
+		support: number;
+		resistance: number;
+		percent_change: number;
+		tradeSplit?: number;
+		take_profit?: number;
+		kind: "long" | "short";
+		entry: number;
+		stop: number;
+		min_size: number;
+		price_places?: string;
+		strategy?: "quantity" | "entry";
+		as_array?: boolean;
+		decimal_places?: string;
+		min_profit?: number;
+		raw?: boolean;
+		gap?: number;
+		rr?: number;
+		max_size?: number;
+	};
 }
-export interface CodeNode {
+export type SignalConfigType = {
+	focus: number;
+	budget: number;
+	percent_change?: number;
+	price_places?: string;
+	decimal_places?: string;
+	zone_risk?: number;
+	fee?: number;
+	support?: number;
+	risk_reward?: number;
+	resistance?: number;
+	risk_per_trade?: number;
+	increase_size?: boolean;
+	additional_increase?: number;
+	minimum_pnl?: number;
+	take_profit?: number;
+	increase_position?: boolean;
+	minimum_size?: number;
+	first_order_size?: number;
+	gap?: number;
+	max_size?: number;
+};
+declare class Signal {
+	focus: number;
+	budget: number;
+	percent_change: number;
+	price_places: string;
+	decimal_places: string;
+	zone_risk: number;
+	fee: number;
+	support?: number;
+	risk_reward: number;
+	resistance?: number;
+	risk_per_trade?: number;
+	increase_size: boolean;
+	additional_increase: number;
 	minimum_pnl: number;
+	take_profit?: number;
+	increase_position: boolean;
+	minimum_size: any;
+	first_order_size: number;
+	gap: number;
 	max_size: number;
-	profit: number;
-	ratio?: number;
-	increase: boolean;
-	not_reduce?: boolean;
-	reduce_ratio?: number;
-	use_full?: boolean;
+	constructor({ focus, budget, percent_change, price_places, decimal_places, zone_risk, fee, support, risk_reward, resistance, risk_per_trade, increase_size, additional_increase, minimum_pnl, take_profit, increase_position, minimum_size, first_order_size, gap, max_size, }: SignalConfigType);
+	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, }: {
+		take_profit?: number;
+		no_of_trades?: number;
+		current_price: number;
+		stop_loss?: number;
+		kind?: "long" | "short";
+		risk: number;
+		stop_percent?: number;
+		pnl?: number;
+	}): any;
+	get risk(): number;
+	get min_trades(): number;
+	get min_price(): number;
+	build_opposite_order({ current_price, kind, }: {
+		current_price: number;
+		kind?: "long" | "short";
+	}): any;
+	special_build_orders({ current_price, kind, }: {
+		current_price: number;
+		kind?: "long" | "short";
+	}): any;
+	build_orders({ current_price, kind, limit, replace_focus, max_index, min_index, }: {
+		current_price: number;
+		kind?: "long" | "short";
+		limit?: boolean;
+		replace_focus?: boolean;
+		max_index?: number;
+		min_index?: number;
+	}): any;
+	build_orders_old({ current_price, kind, limit, replace_focus, max_index, min_index, }: {
+		current_price: number;
+		kind?: "long" | "short";
+		limit?: boolean;
+		replace_focus?: boolean;
+		max_index?: number;
+		min_index?: number;
+	}): any;
+	get_bulk_trade_zones({ current_price, kind, limit, }: {
+		current_price: number;
+		kind?: "long" | "short";
+		limit?: boolean;
+	}): any;
+	get_future_zones({ current_price, kind, raw, }: {
+		raw?: boolean;
+		current_price: number;
+		kind?: "long" | "short";
+	}): number[];
+	to_f(value: number, places?: string): number;
+	get_margin_zones({ current_price, kind, }: {
+		current_price: number;
+		kind?: "long" | "short";
+	}): number[][];
+	get_margin_range(current_price: number, kind?: string): number[];
+	process_orders({ current_price, stop_loss, trade_zones, kind, }: {
+		current_price: number;
+		stop_loss: number;
+		trade_zones: number[];
+		kind?: "long" | "short";
+	}): any[];
+	get_risk_per_trade(number_of_orders: number): number;
+	build_trade_dict({ entry, stop, risk, arr, index, new_fees, kind, start, take_profit, }: {
+		entry: number;
+		stop: number;
+		risk: number;
+		arr: number[];
+		index: number;
+		new_fees?: number;
+		kind?: "long" | "short";
+		start?: number;
+		take_profit?: number;
+	}): {
+		entry: number;
+		risk: number;
+		quantity: number;
+		sell_price: number;
+		risk_sell: number;
+		stop: number;
+		pnl: number;
+		fee: number;
+		net: number;
+		incurred: number;
+		stop_percent: number;
+	};
+	to_df(currentPrice: number, places?: string): number;
 }
+export declare function determine_average_entry_and_size(orders: Array<{
+	price: number;
+	quantity: number;
+}>, places?: string, price_places?: string): {
+	entry: number;
+	price: number;
+	quantity: number;
+};
+export declare const createArray: (start: number, stop: number, step: number) => number[];
 export type AppConfig = {
 	fee: number;
 	risk_per_trade: number;
@@ -379,16 +829,311 @@ export type AppConfig = {
 	gap?: number;
 	rr?: number;
 	max_size?: number;
+	last_value?: any;
+	entries?: any[];
+};
+export type ExtendConfigType = {
+	take_profit?: number;
+	entry: number;
+	risk?: number;
+	stop?: number;
+	risk_reward?: number;
+	raw_instance?: boolean;
+	no_of_trades?: number;
+	increase?: boolean;
+	price_places?: string;
+	decimal_places?: string;
+	min_profit?: number;
+	kind?: "long" | "short";
+	gap?: number;
+	rr?: number;
+};
+export declare function buildConfig(app_config: AppConfig, { take_profit, entry, stop, raw_instance, risk, no_of_trades, min_profit, risk_reward, kind, increase, gap, rr, price_places, decimal_places, }: ExtendConfigType): any[] | Signal;
+export declare function buildAvg({ _trades, kind, }: {
+	_trades: any[];
+	kind: "long" | "short";
+}): any;
+export declare function sortedBuildConfig(app_config: AppConfig, options: any): any[];
+export declare function get_app_config_and_max_size(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	kind: "long" | "short";
+}): {
+	app_config: AppConfig;
+	max_size: any;
+	last_value: any;
+	entries: {
+		entry: any;
+		avg_entry: any;
+		avg_size: any;
+		neg_pnl: any;
+		quantity: any;
+	}[];
+};
+export declare function buildAppConfig(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	risk: number;
+	symbol: string;
+	profit?: number;
+}): AppConfig;
+export declare function getOptimumStopAndRisk(app_config: AppConfig, params: {
+	max_size: number;
+	target_stop: number;
+	highest_risk?: number;
+}): {
+	optimal_stop: number;
+	optimal_risk: number;
+	avg_size: any;
+	avg_entry: any;
+	result: any[];
+	first_entry: any;
+	neg_pnl: any;
+	risk_reward: number;
+	size_diff: number;
+	entry_diff: number;
+};
+export declare function generate_config_params(app_config: AppConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	risk: number;
+	symbol: string;
+}): {
+	entry: number;
+	stop: number;
+	avg_size: any;
+	avg_entry: any;
+	risk_reward: number;
+	neg_pnl: any;
+	risk: number;
+};
+export declare function determine_break_even_price(payload: {
+	long_position: {
+		entry: number;
+		quantity: number;
+	};
+	short_position: {
+		entry: number;
+		quantity: number;
+	};
+	fee_percent?: number;
+}): {
+	price: number;
+	direction: string;
+};
+export declare function determine_amount_to_buy(payload: {
+	orders: any[];
+	kind: "long" | "short";
+	decimal_places?: string;
+	price_places?: string;
+	place?: boolean;
+	position: any;
+	existingOrders: any[];
+}): any[];
+export declare function generateOptimumAppConfig(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	start_risk: number;
+	max_risk?: number;
+}, position: {
+	entry: number;
+	quantity: number;
+	kind: "long" | "short";
+}): AppConfig | null;
+export declare function determineOptimumReward(app_config: AppConfig, increase?: boolean, low_range?: number, high_range?: number): number | {
+	result: any[];
+	value: number;
+	total: number;
+	risk_per_trade: number;
+	max: number;
+	min: number;
+	neg_pnl: any;
+	entry: any;
+};
+export declare function computeRiskReward(payload: {
+	app_config: AppConfig;
+	entry: number;
+	stop: number;
+	risk_per_trade: number;
+}): number | {
+	result: any[];
+	value: number;
+	total: number;
+	risk_per_trade: number;
+	max: number;
+	min: number;
+	neg_pnl: any;
+	entry: any;
 };
+export declare function getRiskReward(payload: {
+	entry: number;
+	stop: number;
+	risk: number;
+	global_config: GlobalConfig;
+}): any;
+declare class ExchangePosition {
+	exchange: BaseExchange;
+	exchange_account: ExchangeAccount$1;
+	private app_db;
+	private instance;
+	constructor(payload: {
+		exchange: BaseExchange;
+		app_db: AppDatabase;
+		instance: PositionsView;
+		exchange_account: ExchangeAccount$1;
+		without_view?: PositionsView;
+	});
+	get symbol(): any;
+	get kind(): any;
+	get account(): any;
+	cancelOrders(payload: {
+		limit?: boolean;
+		price?: number;
+	}): Promise<void | {
+		success: boolean;
+		message: string;
+		exchange_result?: undefined;
+		error?: undefined;
+	} | {
+		success: boolean;
+		exchange_result: any;
+		message?: undefined;
+		error?: undefined;
+	} | {
+		success: boolean;
+		error: any;
+		message?: undefined;
+		exchange_result?: undefined;
+	}>;
+	getConfig(payload?: {
+		params?: {
+			entry?: number;
+			stop?: number;
+			risk_reward?: number;
+			risk?: number;
+			profit_percent?: number;
+			place_tp?: boolean;
+			profit?: number;
+		};
+	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
+	updateTargetPnl(): Promise<number>;
+	updateConfigPnl(): Promise<void>;
+	triggerTradeFromConfig(payload: {
+		place?: boolean;
+		raw?: boolean;
+		tp?: boolean;
+		stop?: boolean;
+		use_current?: boolean;
+		ignore_config?: boolean;
+	}): Promise<any>;
+	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders", payload: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		place?: boolean;
+		update_db?: boolean;
+		raw?: boolean;
+		use_current?: boolean;
+	}): Promise<any>;
+	buildAppConfig(payload: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		profit?: number;
+		update_db?: boolean;
+		profit_percent?: number;
+	}): Promise<AppConfig>;
+	placeConfigOrders(app_config: AppConfig, solution: {
+		risk_reward: number;
+		entry: number;
+		stop: number;
+		risk_per_trade: number;
+		avg_size: number;
+		neg_pnl: number;
+		min_size: number;
+		symbol: string;
+	}, place?: boolean, skip_stop?: boolean): Promise<{
+		entry_orders: {
+			orders: {
+				entry: any;
+				quantity: any;
+				reverse_avg_entry: any;
+				reverse_avg_quantity: any;
+				avg_entry: any;
+				avg_size: any;
+			}[];
+			kind: "long" | "short";
+		};
+		stop_orders: {
+			stop: number;
+			final_stop: number;
+			kind: "long" | "short";
+			quantity: any;
+			is_limit: boolean;
+			neg_pnl: any;
+		};
+		trades: any[];
+	}>;
+	determineAmountToBuy(payload: {
+		orders: any[];
+		kind: "long" | "short";
+		refresh?: boolean;
+		decimal_places?: string;
+		price_places?: string;
+		cancel?: boolean;
+		place?: boolean;
+	}): Promise<any[]>;
+	refresh(live_refresh?: boolean): Promise<{
+		instance: PositionsView;
+		existingOrders: void | Order[];
+	}>;
+	placeTrade(payload: {
+		place?: boolean;
+		tp?: boolean;
+		stop?: boolean;
+		raw?: boolean;
+		cancel?: boolean;
+		ignore_config?: boolean;
+	}): Promise<any>;
+}
 declare class ExchangeAccount$1 {
 	private instance;
-	private exchange;
+	exchange: BaseExchange;
+	main_exchange?: BaseExchange;
 	private app_db;
+	private long_position?;
+	private short_position?;
 	constructor(payload: ExchangeType, options: {
 		exchange: BaseExchange;
 		app_db: AppDatabase;
+		main_exchange?: BaseExchange;
 	});
-	getActiveAccount(symbol: string, full?: boolean): Promise<Account | {
+	/**
+	 *In order to avoid rate limiting issues, we cache the live exchange
+	 details for each symbol for an account in the database with an option
+	 to refresh.
+	 */
+	getDBInstance(): AppDatabase;
+	getLiveExchangeInstance(payload: {
+		symbol: string;
+		refresh?: boolean;
+		refresh_symbol_config?: boolean;
+	}): Promise<import("pocketbase").RecordModel>;
+	initializePositions(payload: {
+		symbol: string;
+		as_view?: boolean;
+		kind: "long" | "short";
+	}): Promise<ExchangePosition>;
+	getActiveAccount(payload: {
+		symbol: string;
+		full?: boolean;
+		refresh?: boolean;
+	}): Promise<Account | {
 		liquidation: {
 			long: number;
 			short: number;
@@ -397,34 +1142,48 @@ declare class ExchangeAccount$1 {
 		current_price: any;
 		exchange: any;
 	}>;
-	syncAccount(options: {
+	refreshAccount(payload: {
 		symbol: string;
-		kind?: "long" | "short";
-		update?: boolean;
-		as_view?: boolean;
+		live_refresh?: boolean;
 		leverage?: number;
 	}): Promise<(PositionsView & {
 		expand?: {
 			config: ScheduledTrade;
+			account: ExchangeAccount;
 		};
-	}) | (PositionsView & {
+	})[]>;
+	syncAccount(options: {
+		symbol: string;
+		kind?: "long" | "short";
+		update?: boolean;
+		as_view?: boolean;
+		leverage?: number;
+		live_refresh?: boolean;
+	}): Promise<PositionsView | (PositionsView & {
 		expand?: {
 			config: ScheduledTrade;
+			account: ExchangeAccount;
 		};
 	})[]>;
 	getRunningInstanceFromDB(symbol: string): Promise<TradeBlockTracking>;
 	syncOrders(options: {
 		symbol: string;
-		kind: "long" | "short";
+		kind?: "long" | "short";
 		update?: boolean;
-	}): Promise<import("pocketbase").RecordModel[]>;
+	}): Promise<void | Order[]>;
+	toggleStopBuying(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		should_stop?: boolean;
+	}): Promise<import("pocketbase").RecordModel>;
 	cancelOrders(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		price?: number;
 		all?: boolean;
 		stop?: boolean;
-	}): Promise<{
+		limit?: boolean;
+	}): Promise<void | {
 		success: boolean;
 		message: string;
 		exchange_result?: undefined;
@@ -444,6 +1203,12 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		orders: number[];
 	}): Promise<any>;
+	getBreakEvenPrice(payload: {
+		symbol: string;
+	}): Promise<{
+		price: number;
+		direction: string;
+	}>;
 	buildAppConfig(payload: {
 		entry: number;
 		stop: number;
@@ -454,6 +1219,36 @@ declare class ExchangeAccount$1 {
 		update_db?: boolean;
 		profit_percent?: number;
 	}): Promise<AppConfig>;
+	tradeConfig(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<AppConfig>;
+	justInTimeProfit(payload: {
+		symbol: string;
+		target_pnl: number;
+		kind: "long" | "short";
+		refresh?: boolean;
+		place?: boolean;
+		take_profit?: number;
+		pause_tp?: boolean;
+	}): Promise<{
+		sell_ratio: number;
+		current_pnl: number;
+		profit_percent: number;
+		current_price: number;
+		notional_value: number;
+	}>;
+	buildTrades(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		risk?: number;
+	}): Promise<{
+		trades: any[];
+		max_size: any;
+		last_price: any;
+		total_size: number;
+		avg_entry: number;
+	}>;
 	placeConfigOrders(app_config: AppConfig, solution: {
 		risk_reward: number;
 		entry: number;
@@ -481,9 +1276,20 @@ declare class ExchangeAccount$1 {
 			kind: "long" | "short";
 			quantity: any;
 			is_limit: boolean;
+			neg_pnl: any;
 		};
 		trades: any[];
 	}>;
+	determineAmountToBuy(payload: {
+		orders: any[];
+		kind: "long" | "short";
+		refresh?: boolean;
+		decimal_places?: string;
+		price_places?: string;
+		symbol: string;
+		cancel?: boolean;
+		place?: boolean;
+	}): Promise<any[]>;
 	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders", payload: {
 		symbol: string;
 		entry: number;
@@ -492,44 +1298,277 @@ declare class ExchangeAccount$1 {
 		risk: number;
 		place?: boolean;
 		update_db?: boolean;
+		raw?: boolean;
+		use_current?: boolean;
 	}): Promise<any>;
+	getOrCreatePositionConfig(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		risk?: number;
+		risk_reward?: number;
+	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
 	getPositionConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		params?: {
-			entry: number;
-			stop: number;
-			risk_reward: number;
-			risk: number;
+			entry?: number;
+			stop?: number;
+			risk_reward?: number;
+			risk?: number;
 			profit_percent?: number;
+			place_tp?: boolean;
+			profit?: number;
 		};
-	}): Promise<import("pocketbase").RecordModel>;
+	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
 	getCurrentPrice(symbol: string): Promise<any>;
-	getPositionStrategy(): Promise<{
-		strategy_instance: Strategy;
-		focus_account: ExchangeAccount;
+	getPositionStrategy(): Promise<AccountStrategy>;
+	buildReduceConfig(payload: {
+		symbol: string;
+		kind?: "long" | "short";
+		as_dict?: boolean;
+		target_pnl?: number;
+		trigger?: {
+			long: boolean;
+			short: boolean;
+		};
+		use_full?: boolean;
+	}): Promise<{
+		trigger_short: boolean;
+		trigger_long: boolean;
+		symbol: string;
+		short_minimum_pnl: number;
+		long_minimum_pnl: number;
+		short_profit: any;
+		long_profit: any;
+		owner: string;
+		exchange: string;
+		not_reduce: boolean;
+		reduce_ratio_long: any;
+		reduce_ratio_short: any;
+		use_full_long: any;
+		use_full_short: any;
+	} | {
+		long: {
+			minimum_pnl: number;
+			max_size: number;
+			profit: any;
+			increase: boolean;
+			not_reduce: boolean;
+			ratio: any;
+			use_full: boolean;
+			sell_ratio: any;
+		};
+		short: {
+			minimum_pnl: number;
+			max_size: number;
+			profit: any;
+			increase: boolean;
+			not_reduce: boolean;
+			ratio: any;
+			use_full: boolean;
+			sell_ratio: any;
+		};
+		trigger: {
+			long: boolean;
+			short: boolean;
+		};
 	}>;
 	getOriginalPlannedStop(payload: {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<any>;
-	syncReduceClosePosition(symbol: string, payload?: {
+	syncReduceClosePosition(payload?: {
+		symbol: string;
 		kind?: "long" | "short";
-		long?: CodeNode;
-		short?: CodeNode;
-		trigger?: {
+		trigger?: boolean;
+	}): Promise<any>;
+	reduceMajorPositionEntry(payload: {
+		symbol: string;
+		long: any;
+		short: any;
+		trigger: {
 			long: boolean;
 			short: boolean;
 		};
 	}): Promise<any>;
+	placeProfitAndStop(payload: {
+		symbol: string;
+		trigger?: boolean;
+		refresh?: boolean;
+		kind?: "long" | "short";
+		target_pnl?: number;
+	}): Promise<any>;
+	reEnterPositionOnEmpty(symbol: string): Promise<void>;
+	generate_config_params(payload: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		symbol: string;
+		with_trades?: boolean;
+	}): Promise<any>;
+	build_short_order(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<any>;
+	extrapolateShortConfig(payload: {
+		kind: "long" | "short";
+		symbol: string;
+		risk_reward?: number;
+		risk?: number;
+	}): Promise<any>;
+	placeMarketOrder(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		quantity: number;
+	}): Promise<void>;
+	placeSingleOrder(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<string>;
+	triggerTradeFromConfig(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+		raw?: boolean;
+		tp?: boolean;
+		stop?: boolean;
+		use_current?: boolean;
+		ignore_config?: boolean;
+	}): Promise<any>;
+	verifyStopLoss(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		revert?: boolean;
+	}): Promise<void | Order[]>;
+	windDownSymbol(payload: {
+		symbol: string;
+		risk_reward?: number;
+		risk?: number;
+	}): Promise<void>;
+	updateTargetPnl(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<number>;
+	runSimulation(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		iterations?: number;
+		raw?: boolean;
+	}): Promise<Strategy | {
+		[x: string]: any;
+		risk: number;
+		risk_reward: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	}[]>;
+	getCurrentRun(payload: {
+		symbol: string;
+		kind?: "long" | "short";
+		pnl?: number;
+	}): Promise<true | import("pocketbase").RecordModel>;
+	recomputeSymbolConfig(payload: {
+		symbol: string;
+		refresh?: boolean;
+	}): Promise<SymbolConfig>;
+	/**
+	 * This function builds a config for a symbol
+	 * @param payload
+	 * @returns
+	 */
+	buildConfigForSymbol(payload: {
+		symbol: string;
+		risk: number;
+		kind?: "long" | "short";
+		risk_reward?: number;
+		as_config?: boolean;
+		with_trades?: boolean;
+	}): Promise<any>;
+	triggerBullishMarket(payload: {
+		symbol: string;
+		profit_percent?: number;
+		risk_reward?: number;
+	}): Promise<any>;
+	updateAllActiveSymbols(payload: {
+		interval?: number;
+	}): Promise<void>;
+	updateAllPositionsWithNoConfig(payload: {
+		kind: "long" | "short";
+	}): Promise<void>;
+	getSymbolsForPositions(): Promise<any[]>;
+	getNonEssentialSymbols(): Promise<any[]>;
+	_terminatePositions(payload: {
+		symbol: string;
+	}): Promise<void>;
+	getOrders(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		type: "limit" | "stop" | "tp";
+	}): Promise<Order[]>;
+	syncPositionConfigs(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		refresh?: boolean;
+	}): Promise<void>;
+	terminatePositions(payload: {
+		symbol: string;
+	}): Promise<void>;
+	fetchAndUpdateTopMovers(): Promise<{
+		updated_bullish: BullishMarket[];
+		moved_to_winding: WindingDownMarket[];
+	}>;
+	computeTargetPnl(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<number>;
+	placeTrade(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+		tp?: boolean;
+		stop?: boolean;
+		raw?: boolean;
+		cancel?: boolean;
+		ignore_config?: boolean;
+		target_pnl?: number;
+	}): Promise<any>;
+	updateConfigPnl(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<void>;
 }
+declare function getExchangeAccount(payload: {
+	account: ExchangeType;
+	app_db: AppDatabase;
+	getCredentials: (account: string, exchange: string) => {
+		api_key: string;
+		api_secret: string;
+		email: string;
+	};
+	proxyOptions?: {
+		proxy?: any;
+		ignore_proxy?: boolean;
+	};
+	canWithdraw?: boolean;
+}): Promise<ExchangeAccount$1>;
 declare class App {
-	private app_db;
+	app_db: AppDatabase;
+	proxyOptions?: {
+		proxy?: any;
+		ignore_proxy?: boolean;
+		canWithdraw?: boolean;
+	};
 	private getCredentials;
-	constructor(app_db: AppDatabase, getCredentials: (account: string, exchange: string) => (account: string, exchange: string) => Promise<{
+	constructor(app_db: AppDatabase, getCredentials: (account: string, exchange: string) => {
 		api_key: string;
 		api_secret: string;
-	}>);
+		email: string;
+	}, proxyOptions?: {
+		proxy?: any;
+		ignore_proxy?: boolean;
+		canWithdraw?: boolean;
+	});
 	getExchangeAccount(account: ExchangeType): Promise<ExchangeAccount$1>;
 	syncAccount(payload: {
 		account: ExchangeType;
@@ -537,13 +1576,10 @@ declare class App {
 		kind?: "long" | "short";
 		update?: boolean;
 		as_view?: boolean;
-	}): Promise<(PositionsView & {
-		expand?: {
-			config: ScheduledTrade;
-		};
-	}) | (PositionsView & {
+	}): Promise<PositionsView | (PositionsView & {
 		expand?: {
 			config: ScheduledTrade;
+			account: ExchangeAccount;
 		};
 	})[]>;
 	syncOrders(payload: {
@@ -558,7 +1594,7 @@ declare class App {
 		price?: number;
 		all?: boolean;
 		stop?: boolean;
-	}): Promise<{
+	}): Promise<void | {
 		success: boolean;
 		message: string;
 		exchange_result?: undefined;
@@ -574,41 +1610,6 @@ declare class App {
 		message?: undefined;
 		exchange_result?: undefined;
 	}>;
-	triggerTradeFromConfig(payload: {
-		account: ExchangeType;
-		symbol: string;
-		kind: "long" | "short";
-	}): Promise<any>;
-	toggleStopBuying(payload: {
-		account: ExchangeType;
-		symbol: string;
-		kind: "long" | "short";
-		should_stop?: boolean;
-	}): Promise<import("pocketbase").RecordModel>;
-	generate_config_params(exchange_account: ExchangeAccount$1, payload: {
-		entry: number;
-		stop: number;
-		risk_reward: number;
-		risk: number;
-		symbol: string;
-	}): Promise<{
-		place_stop: boolean;
-		profit_percent: number;
-		entry: number;
-		stop: number;
-		avg_size: any;
-		avg_entry: any;
-		risk_reward: number;
-		neg_pnl: any;
-		risk: number;
-	}>;
-	generateConfig(payload: {
-		account: ExchangeType;
-		symbol: string;
-		kind: "long" | "short";
-		update_orders?: boolean;
-		place_orders?: boolean;
-	}): Promise<any>;
 	updateReduceRatio(payload: {
 		account: ExchangeType;
 		symbol: string;
@@ -619,38 +1620,6 @@ declare class App {
 		short_db_position: any;
 		balance: any;
 	}>;
-	extrapolateShortConfig(payload: {
-		account: ExchangeType;
-		kind: "long" | "short";
-		symbol: string;
-		risk_reward?: number;
-	}): Promise<PositionsView | {
-		place_stop: boolean;
-		profit_percent: number;
-		entry: number;
-		stop: number;
-		avg_size: any;
-		avg_entry: any;
-		risk_reward: number;
-		neg_pnl: any;
-		risk: number;
-	}>;
-	verifyStopLoss(payload: {
-		account: ExchangeType;
-		symbol: string;
-		kind: "long" | "short";
-		revert?: boolean;
-	}): Promise<import("pocketbase").RecordModel[]>;
-	updateTopMovers(payload?: {
-		new_markets: {
-			symbol: string;
-			percent: number;
-		}[];
-		totalRisk: number;
-	}): Promise<{
-		updated_bullish: BullishMarket[];
-		moved_to_winding: WindingDownMarket[];
-	}>;
 	getWindingDownMarkets(): Promise<WindingDownMarket[]>;
 	updateSymbolConfigs(payload: {
 		configs: {
@@ -662,10 +1631,41 @@ declare class App {
 			price_places: string;
 			decimal_places: string;
 		}[];
-	}): Promise<{
+	}): Promise<SymbolConfig[] | {
 		updated: number;
 		created: number;
-	} | SymbolConfig[]>;
+	}>;
+	updateAllAccountWithSymbols(with_positions?: boolean): Promise<void>;
+	windDownSymbol(payload: {
+		symbol: string;
+		risk?: number;
+	}): Promise<boolean>;
+	getNonEssentialSymbols(): Promise<Set<any>>;
+	refreshAllPositionsWithSymbol(payload: {
+		symbol: string;
+	}): Promise<void>;
+	autoFollowPositions(): Promise<void>;
+	getMoverExchangeInstances(): Promise<ExchangeAccount[]>;
+	updateTpOnAllMarkets(): Promise<void>;
+	triggerMoverTask(payload: {
+		callback: (params: {
+			symbol: string;
+			account: ExchangeType;
+		}) => Promise<any>;
+		removeCallback?: (params: {
+			symbol: string;
+			account: ExchangeType;
+		}) => Promise<any>;
+	}): Promise<void>;
+	placeTrade(payload: {
+		account: ExchangeType;
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+		tp?: boolean;
+		cancel?: boolean;
+		raw?: boolean;
+	}): Promise<any>;
 }
 export declare function initApp(payload: {
 	db: {
@@ -673,14 +1673,44 @@ export declare function initApp(payload: {
 		email: string;
 		password: string;
 	};
-	getCredentials: (account: string, exchange: string) => (account: string, exchange: string) => Promise<{
+	password?: string;
+	getCredentials: (account: string, exchange: string) => {
 		api_key: string;
 		api_secret: string;
-	}>;
+		email: string;
+	};
+	proxy?: any;
+	ignore_proxy?: boolean;
+	canWithdraw?: boolean;
+	triggerToken?: string;
+}): Promise<App>;
+declare function getCredentials(account: string, exchange: string): {
+	api_key: string;
+	api_secret: string;
+	email: string;
+};
+export declare function initialize(payload: {
+	password?: string;
+	proxy?: any;
+	ignore_proxy?: boolean;
+	canWithdraw?: boolean;
 }): Promise<App>;
 
+declare namespace database {
+	export { AppDatabase, ExchangeType, initPocketBaseClient };
+}
+declare namespace exchange_account {
+	export { ExchangeAccount$1 as ExchangeAccount, getExchangeAccount };
+}
+declare namespace app {
+	export { App, getCredentials, initApp, initialize };
+}
+
 export {
 	ExchangeAccount$1 as ExchangeAccount,
+	app,
+	database,
+	exchange_account,
 };
 
 export {};