@gbozee/ultimate 0.0.2-98 → 0.0.2-next.0

package/dist/index.d.ts

@@ -5,6 +5,21 @@ import PocketBase from 'pocketbase';
 import { RecordModel as PocketBaseRecordModel } from 'pocketbase';
 import { SocksProxyAgent } from 'socks-proxy-agent';
 
+export interface GetEntriesParams {
+	kind: "long" | "short";
+	distribution: "arithmetic" | "geometric" | "normal" | "exponential" | "inverse-exponential";
+	margin_range: [
+		number,
+		number
+	];
+	risk_reward: number;
+	price_places?: string;
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+}
 export type RecordModel = PocketBaseRecordModel;
 export interface BaseSystemFields {
 	id: string;
@@ -71,6 +86,32 @@ export interface ScheduledTrade extends BaseSystemFields {
 	sell_ratio?: number;
 	threshold_qty?: number;
 	pause_tp?: boolean;
+	stop_percent?: number;
+	kelly?: {
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+	settings?: {
+		gap_trading?: {
+			entry_risk?: number;
+			hedge_stop_ratio?: number;
+		};
+		bad_hedge?: {
+			hedges_distribution?: GetEntriesParams["distribution"];
+			hedges_ratio?: number;
+			opposite_trade_distribution?: GetEntriesParams["distribution"];
+			opposite_trade_ratio?: number;
+			stop_loss?: number;
+		};
+	};
 }
 export interface AccountStrategy extends BaseSystemFields {
 	account: string;
@@ -83,16 +124,13 @@ export interface AccountStrategy extends BaseSystemFields {
 	running?: boolean;
 	max_reward_factor?: number;
 	follow?: boolean;
+	risk_reward?: number;
+	dynamic?: 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;
@@ -122,6 +160,26 @@ export interface PositionsView {
 	follow?: boolean | 1 | 0;
 	current_price?: number;
 	usd_balance?: number;
+	tp?: {
+		price: number;
+		quantity: number;
+	};
+	next_risk?: number;
+	proxy?: string;
+	expand?: {
+		p_account?: ExchangeAccount;
+		b_config?: ScheduledTrade;
+		proxy?: Proxy$1;
+		account_strategy?: AccountStrategy;
+		compound_instance?: CompoundInstance;
+		support?: SupportTable;
+		symbol_config: SymbolConfig;
+		resistance?: SupportTable;
+		anchor?: Omit<PositionsView, "expand">;
+		record?: any;
+	};
+	pnl?: number;
+	support_price?: number;
 }
 export interface BullishMarket extends RecordModel {
 	id: string;
@@ -133,26 +191,54 @@ export interface WindingDownMarket extends RecordModel {
 	symbol: string;
 	risk_reward: number;
 }
+export interface Compounder extends BaseSystemFields {
+	risk?: number;
+	profit_percent?: number;
+	owner?: string;
+	completed?: boolean;
+	start_balance?: number;
+	starting_risk?: number;
+	fee_rate?: number;
+}
+export interface CompoundInstance extends BaseSystemFields {
+	ref?: string;
+	position?: string;
+	risk?: number;
+	hedged?: boolean;
+	loss?: number;
+	expand?: {
+		ref?: Compounder;
+	};
+}
+export interface SupportTable extends BaseSystemFields {
+	symbol?: string;
+	price?: number;
+	counter?: number;
+	last_updated?: string;
+	kind?: "long" | "short";
+}
 export type GlobalConfig = {
-	profit_percent: number;
+	profit_percent?: number;
 	symbol: string;
-	profit: number;
-	risk: number;
-	stop_percent: number;
+	profit?: number;
+	risk?: number;
+	stop_percent?: number;
 	kind: "long" | "short";
-	reduce_percent: number;
+	reduce_percent?: number;
 	support: number;
 	resistance: number;
 	price_places: string;
 	decimal_places: string;
-	min_size: number;
-	accounts: {
+	min_size?: number;
+	accounts?: {
 		owner: string;
 		exchange?: string;
 	}[];
-	risk_reward: number;
-	reverse_factor: number;
+	risk_reward?: number;
+	reverse_factor?: number;
 	leverage?: number;
+	max_quantity?: number;
+	fee_percent?: number;
 };
 interface Position$1 {
 	id: number;
@@ -169,6 +255,7 @@ interface Position$1 {
 	target_pnl?: number;
 	reduce_ratio?: number;
 	use_full?: boolean;
+	liquidation?: number;
 }
 export interface Account {
 	id: number | string;
@@ -218,40 +305,86 @@ interface Order$1 {
 	stop: number;
 	triggerPrice?: number;
 }
+export interface CandlestickAnalysisResult {
+	candlesticks: {
+		[key: string]: any[];
+	};
+	resistance: {
+		[key: string]: number;
+	};
+	support: {
+		[key: string]: number;
+	};
+	current_price: number;
+	minimum_weekly: number;
+}
 declare abstract class BaseExchange {
 	client: any;
+	name: string;
+	getCredentials: (payload: {
+		account: string;
+	}) => Promise<{
+		api_key: string;
+		api_secret: string;
+		email: string;
+	}>;
+	proxyAgent?: any;
+	remoteActionBaseUrl?: string;
 	constructor(client: any);
-	abstract rawCreateLimitPurchaseOrders(payload: {
+	protected abstract getPositionInfo(symbol: string): Promise<any>;
+	abstract cancelAllOrders(symbol: string, payload: {
+		type?: "limit" | "stop" | "tp";
+		side?: "buy" | "sell";
+		kind?: "long" | "short";
+	}): Promise<any>;
+	protected abstract getCurrentPrice(symbol: string): Promise<any>;
+	protected abstract getExchangeInfo(options: {
+		price_places?: string;
+		decimal_places?: string;
+		account: {
+			owner: string;
+			exchange: string;
+		};
+		symbol: string;
+	}): Promise<any>;
+	protected abstract _createLimitPurchaseOrders(payload: {
+		symbol: string;
+		orders: any[];
+		price_places?: string;
+		decimal_places?: string;
+	}): Promise<any>;
+	rawCreateLimitPurchaseOrders(payload: {
 		symbol: string;
 		orders: Order$1[];
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
-	abstract placeStopOrders(payload: {
+	placeStopOrders(payload: {
 		symbol: string;
 		quantity: number;
 		kind: "long" | "short";
 		stop: number;
 		price_places?: string;
 		decimal_places?: string;
+		hedge?: boolean;
 		place?: boolean;
 	}): Promise<any>;
-	abstract bulkPlaceLimitOrders(payload: {
-		orders: any[];
+	bulkPlaceLimitOrders(payload: {
+		orders: Order$1[];
 		kind: "long" | "short";
 		decimal_places?: string;
 		price_places?: string;
 		symbol: string;
 		place?: boolean;
-	}): Promise<any>;
-	abstract get_current_price(symbol: string): Promise<any>;
+	}): Promise<any[]>;
+	get_current_price(symbol: string): Promise<any>;
 	abstract analyzeCharts(payload: {
 		symbol: string;
 		chartType: any;
-		count: number;
+		limit: number;
 		raw?: boolean;
 	}): Promise<any>;
-	abstract getExchangeAccountInfo(options: {
+	getExchangeAccountInfo(options: {
 		price_places?: string;
 		decimal_places?: string;
 		account: {
@@ -260,11 +393,27 @@ declare abstract class BaseExchange {
 		};
 		symbol: string;
 	}): Promise<any>;
-	abstract cancelOrders(payload: {
+	protected abstract _cancelOrders(payload: {
+		symbol: string;
+		orders: Array<{
+			orderId?: any;
+			clientOrderId?: any;
+		}>;
+	}): Promise<any>;
+	cancelOrders(payload: {
 		symbol: string;
 		orders: number[];
 	}): Promise<any>;
-	abstract placeTpOrder(payload: {
+	protected abstract _placeTpOrder(payload: {
+		symbol: string;
+		tp: number;
+		kind: "long" | "short";
+		cancel?: boolean;
+		quantity?: number;
+		price_places?: string;
+		decimal_places?: string;
+	}): Promise<any>;
+	placeTpOrder(payload: {
 		symbol: string;
 		take_profit: number;
 		kind: "long" | "short";
@@ -273,7 +422,18 @@ declare abstract class BaseExchange {
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
-	abstract placeLimitOrder(payload: {
+	protected abstract placeLimitOrders(payload: {
+		symbol: string;
+		orders: Array<{
+			entry: number;
+			quantity: number;
+		}>;
+		kind: "long" | "short";
+		cancel?: boolean;
+		price_places?: string;
+		decimal_places?: string;
+	}): Promise<any>;
+	placeLimitOrder(payload: {
 		symbol: string;
 		quantity: number;
 		kind: "long" | "short";
@@ -281,13 +441,27 @@ declare abstract class BaseExchange {
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
-	abstract placeStopOrder(payload: {
+	protected abstract _placeStopOrder(payload: {
+		symbol: string;
+		stop: number;
+		quantity: number;
+		kind: "long" | "short";
+		price_places?: string;
+		decimal_places?: string;
+		final_stop: number;
+		cancel?: boolean;
+		is_limit?: boolean;
+		current_price: number;
+		hedge?: boolean;
+	}): Promise<any>;
+	placeStopOrder(payload: {
 		symbol: string;
 		stop: number;
 		quantity: number;
 		kind: "long" | "short";
 		price_places?: string;
 		decimal_places?: string;
+		hedge?: boolean;
 	}): Promise<any>;
 	abstract setLeverage(payload: {
 		symbol: string;
@@ -302,14 +476,15 @@ declare abstract class BaseExchange {
 		movePercent: number;
 		include_delisted?: boolean;
 	}): Promise<any>;
-	abstract closePosition(payload: {
+	closePosition(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
-	abstract getAllOpenSymbols(): Promise<string[]>;
-	abstract createLimitPurchaseOrders(payload: {
+	protected abstract getAllOpenOrders(): Promise<any>;
+	getAllOpenSymbols(): Promise<unknown[]>;
+	createLimitPurchaseOrders(payload: {
 		orders: any[];
 		kind: "long" | "short";
 		decimal_places?: string;
@@ -330,12 +505,13 @@ declare abstract class BaseExchange {
 		asset: string;
 		amount: number;
 	}): Promise<any>;
-	abstract placeMarketOrder(payload: {
+	placeMarketOrder(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		quantity: number;
 		price_places?: string;
 		decimal_places?: string;
+		close?: boolean;
 	}): Promise<any>;
 	customStopLoss(payload: {
 		price_places: string;
@@ -345,8 +521,46 @@ declare abstract class BaseExchange {
 		stop: number;
 		quantity: number;
 		increase?: boolean;
+		place?: boolean;
+		increase_ratio?: number;
+	}): Promise<any>;
+	abstract getOpenOrders(payload: {
+		symbol: string;
+	}): Promise<any>;
+	placeBadStopEntry(payload: {
+		symbol: string;
+		orders: Order$1[];
+		price_places?: string;
+		decimal_places?: string;
 	}): Promise<any>;
+	analyzeCandlesticks(payload: {
+		symbol: string;
+	}): Promise<CandlestickAnalysisResult>;
+	setAccountDetails(payload: {
+		getCredentials: (payload: {
+			account: string;
+		}) => Promise<{
+			api_key: string;
+			api_secret: string;
+			email: string;
+		}>;
+		proxyAgent?: any;
+		remoteActionBaseUrl?: string;
+	}): void;
+	getSymbolInformation(payload: {
+		symbol: string;
+		variant?: "full" | "short";
+	}): Promise<{
+		candlesticks: Record<string, any[]>;
+		resistance: Record<string, number>;
+		support: Record<string, number>;
+		currentPrice: number;
+		minimumWeekly?: number;
+		lowest?: number;
+	}>;
 }
+declare function encryptObject(obj: any, password: string): string;
+declare function decryptObject(encryptedString: string, password: string): any;
 declare function initPocketBaseClient(proxy_credentials: {
 	host: string;
 	email: string;
@@ -359,14 +573,40 @@ export type ExchangeType = {
 };
 export declare class AppDatabase {
 	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;
+	email?: string;
+	salt?: string;
+	constructor(pb: PocketBase, payload: {
+		email?: string;
+		salt?: string;
+	});
+	getUserByEmail(): Promise<import("pocketbase").RecordModel>;
+	verifyUserPassword(password: string): Promise<boolean>;
+	generateUserPassword(): Promise<boolean>;
+	getUserCredentials(): Promise<any>;
+	getCredentials(payload: {
+		password?: string;
+	}): Promise<any>;
+	saveCredentials(params: {
+		password?: string;
+		credentials: any;
+	}): Promise<import("pocketbase").RecordModel>;
+	changeUserPassword(payload: {
+		password: string;
+	}): Promise<boolean>;
+	verifyAdminPassword(password: string): Promise<boolean>;
+	setAdminPassword(payload: {
+		password: string;
+		salt: string;
+	}): Promise<boolean>;
+	addNewCredential(params: {
+		password?: string;
+		payload: {
+			name: string;
+			email: string;
+			exchange: string;
+			api_key: string;
+			api_secret: string;
+		};
 	}): Promise<void>;
 	getAccountWithActivePositions(): Promise<import("pocketbase").RecordModel[]>;
 	getAllSymbolsFromPositions(options?: {
@@ -395,6 +635,12 @@ export declare class AppDatabase {
 			proxy: Proxy$1;
 		};
 	}>;
+	get positionExpand(): string;
+	fetchCentralPositions(payload: {
+		asset?: string;
+		symbol?: string;
+		customFilter?: string;
+	}): Promise<import("pocketbase").RecordModel[]>;
 	getPositions(options: {
 		account?: ExchangeType;
 		symbol?: string;
@@ -404,6 +650,7 @@ export declare class AppDatabase {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	private _createOrUpdatePosition;
@@ -416,14 +663,11 @@ export declare class AppDatabase {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	update_db_position(position: any, payload: any): Promise<import("pocketbase").RecordModel>;
 	getSymbolConfigFromDB(symbol: string): Promise<SymbolConfig>;
-	getRunningInstanceFromDB(account: ExchangeType, symbol: string, options?: {
-		delay?: number;
-	}): Promise<TradeBlockTracking>;
-	updateRunningInstance(id: string, running: boolean): Promise<import("pocketbase").RecordModel>;
 	getOrders(account: ExchangeType, options: {
 		symbol: string;
 		kind: "long" | "short";
@@ -455,17 +699,19 @@ export declare class AppDatabase {
 			stop: number;
 			order_id: string;
 			triggerPrice?: number;
+			clientOrderId?: string;
 		}>;
 	}): Promise<void>;
 	cancelLimitOrders(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		account: ExchangeType;
+		raw?: boolean;
 		cancelExchangeOrders: (payload: {
 			symbol: string;
 			orders: number[];
 		}) => Promise<any>;
-	}): Promise<void>;
+	}): Promise<any[]>;
 	cancelOrders(payload: {
 		cancelExchangeOrders: (payload: {
 			symbol: string;
@@ -508,13 +754,14 @@ export declare class AppDatabase {
 		profit_percent?: number;
 		place_tp?: boolean;
 		profit?: number;
+		reduce_ratio?: number;
 	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
 	getPositionConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		account: ExchangeType;
 	}): Promise<ScheduledTrade | null>;
-	getRunningAccountStrategies(): Promise<(AccountStrategy & {
+	getRunningAccountStrategies(filter?: string): Promise<(AccountStrategy & {
 		expand?: {
 			account: ExchangeAccount;
 		};
@@ -556,10 +803,72 @@ export declare class AppDatabase {
 	} | SymbolConfig[]>;
 	unwindSymbolFromDB(symbol: string): Promise<boolean>;
 	hasExistingPosition(symbol: string): Promise<import("pocketbase").RecordModel[]>;
+	getPositionWithLowestNextOrder(options: {
+		symbol?: string;
+		kind: "long" | "short";
+		asset?: string;
+		exclude?: ExchangeType[];
+	}): Promise<PositionsView | null>;
 	hasExistingOrders(symbol: string): Promise<import("pocketbase").RecordModel[]>;
 	removeSymbolFromUnwindingMarkets(symbol: string): Promise<boolean>;
 	removePosition(position: any): Promise<void>;
 	removePositionConfig(position: any): Promise<void>;
+	getConfigProfiles(payload: {
+		config_id: string;
+	}): Promise<{
+		id: any;
+		entry: any;
+		stop: any;
+		kind: "long" | "short";
+		risk_reward: any;
+		risk: any;
+		profit_percent: any;
+	}[]>;
+	editConfigProfile(payload: {
+		id: string;
+		params: {
+			entry?: number;
+			stop?: number;
+			risk_reward?: number;
+			risk?: number;
+			profit_percent?: number;
+		};
+	}): Promise<void>;
+	createConfigProfile(payload: {
+		config_id: string;
+		symbol: string;
+		params: {
+			entry: number;
+			stop: number;
+			kind: "long" | "short";
+			risk_reward: number;
+			risk: number;
+			profit_percent: number;
+		};
+	}): Promise<void>;
+	getCompoundInstance(payload: {
+		position: Position$1;
+	}): Promise<CompoundInstance & {
+		expand: {
+			ref: Compounder;
+		};
+	}>;
+	getSupportTable(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<SupportTable>;
+	updateCompoundInstance(payload: {
+		id: string;
+		params: any;
+	}): Promise<import("pocketbase").RecordModel>;
+	getPositionsByAssetPair(payload: {
+		asset: string;
+		symbol?: string;
+		isCompound?: boolean;
+	}): Promise<{
+		pairObject: any;
+		asset: string;
+	}>;
 }
 export type StrategyPosition = {
 	entry: number;
@@ -746,15 +1055,48 @@ export declare class Strategy {
 		gap?: number;
 		rr?: number;
 		max_size?: number;
+		max_quantity?: number;
+		kelly?: {
+			use_kelly?: boolean;
+			kelly_confidence_factor?: number;
+			kelly_minimum_risk?: number;
+			kelly_prediction_model?: "exponential" | "normal" | "uniform";
+			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+		};
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	};
 	identifyGapConfig(payload: {
 		factor?: number;
+		sell_factor?: number;
+		kind?: "long" | "short";
+		risk?: number;
 	}): {
-		long_tp: number;
-		short_tp: number;
-		short_to_reduce: number;
-		long_to_reduce: number;
-		to_sell: {
+		profit_percent: {
+			long: number;
+			short: number;
+		};
+		risk: {
+			short: number;
+			long: number;
+		};
+		take_profit: {
+			long: number;
+			short: number;
+		};
+		to_reduce: {
+			short: number;
+			long: number;
+		};
+		full_reduce: {
+			short: number;
+			long: number;
+		};
+		sell_quantity: {
 			short: number;
 			long: number;
 		};
@@ -769,6 +1111,7 @@ export declare class Strategy {
 	}): {
 		pnl: number;
 		loss: number;
+		full_loss: number;
 		original_pnl: number;
 		reward_factor: number;
 		profit_percent: number;
@@ -778,8 +1121,57 @@ export declare class Strategy {
 		price_places: string;
 		decimal_places: string;
 	};
+	simulateGapReduction(payload: {
+		iterations?: number;
+		factor?: number;
+		direction: "long" | "short";
+		kind?: "long" | "short";
+		risk?: number;
+		sell_factor?: number;
+	}): {
+		results: {
+			profit_percent: {
+				long: number;
+				short: number;
+			};
+			risk: {
+				short: number;
+				long: number;
+			};
+			take_profit: {
+				long: number;
+				short: number;
+			};
+			sell_quantity: {
+				short: number;
+				long: number;
+			};
+			gap_loss: number;
+			position: {
+				long: {
+					entry: number;
+					quantity: number;
+				};
+				short: {
+					entry: number;
+					quantity: number;
+				};
+			};
+		}[];
+		quantity: 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 SignalConfigType = {
+	symbol?: string;
 	focus: number;
 	budget: number;
 	percent_change?: number;
@@ -800,12 +1192,32 @@ export type SignalConfigType = {
 	first_order_size?: number;
 	gap?: number;
 	max_size?: number;
+	use_kelly?: boolean;
+	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_confidence_factor?: number;
+	kelly_minimum_risk?: number;
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	full_distribution?: {
+		long: GetEntriesParams["distribution"];
+		short: GetEntriesParams["distribution"];
+	};
+	max_quantity?: number;
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
 declare class Signal {
 	focus: number;
 	budget: number;
 	percent_change: number;
 	price_places: string;
+	distribution_params: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 	decimal_places: string;
 	zone_risk: number;
 	fee: number;
@@ -822,8 +1234,19 @@ declare class Signal {
 	first_order_size: number;
 	gap: number;
 	max_size: number;
-	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, }: {
+	use_kelly: boolean;
+	kelly_prediction_model: "exponential" | "normal" | "uniform";
+	kelly_confidence_factor: number;
+	kelly_minimum_risk: number;
+	kelly_func: "theoretical" | "position_based" | "theoretical_fixed";
+	symbol?: string;
+	distribution: {
+		long: GetEntriesParams["distribution"];
+		short: GetEntriesParams["distribution"];
+	};
+	max_quantity: number;
+	constructor({ focus, symbol, 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, use_kelly, kelly_prediction_model, kelly_confidence_factor, kelly_minimum_risk, kelly_func, full_distribution, max_quantity, distribution_params, }: SignalConfigType);
+	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, distribution, distribution_params, }: {
 		take_profit?: number;
 		no_of_trades?: number;
 		current_price: number;
@@ -832,6 +1255,12 @@ declare class Signal {
 		risk: number;
 		stop_percent?: number;
 		pnl?: number;
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	}): any;
 	get risk(): number;
 	get min_trades(): number;
@@ -865,6 +1294,11 @@ declare class Signal {
 		kind?: "long" | "short";
 		limit?: boolean;
 	}): any;
+	get_future_zones_simple({ current_price, kind, raw, }: {
+		raw?: boolean;
+		current_price: number;
+		kind?: "long" | "short";
+	}): number[];
 	get_future_zones({ current_price, kind, raw, }: {
 		raw?: boolean;
 		current_price: number;
@@ -908,15 +1342,6 @@ declare class Signal {
 	};
 	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;
@@ -944,6 +1369,20 @@ export type AppConfig = {
 	max_size?: number;
 	last_value?: any;
 	entries?: any[];
+	max_quantity?: number;
+	kelly?: {
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
 export type ExtendConfigType = {
 	take_profit?: number;
@@ -960,8 +1399,20 @@ export type ExtendConfigType = {
 	kind?: "long" | "short";
 	gap?: number;
 	rr?: number;
+	min_avg_size?: number;
+	use_kelly?: boolean;
+	kelly_confidence_factor?: number;
+	kelly_minimum_risk?: number;
+	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: 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 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, use_kelly, kelly_confidence_factor, kelly_minimum_risk, kelly_prediction_model, kelly_func, min_avg_size, distribution, distribution_params, }: ExtendConfigType): any[] | Signal;
 export declare function buildAvg({ _trades, kind, }: {
 	_trades: any[];
 	kind: "long" | "short";
@@ -971,6 +1422,17 @@ export declare function get_app_config_and_max_size(config: GlobalConfig, payloa
 	entry: number;
 	stop: number;
 	kind: "long" | "short";
+	use_kelly?: boolean;
+	kelly_confidence_factor?: number;
+	kelly_minimum_risk?: number;
+	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }): {
 	app_config: AppConfig;
 	max_size: any;
@@ -990,11 +1452,28 @@ export declare function buildAppConfig(config: GlobalConfig, payload: {
 	risk: number;
 	symbol: string;
 	profit?: number;
+	use_kelly?: boolean;
+	kelly_confidence_factor?: number;
+	kelly_minimum_risk?: number;
+	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }): AppConfig;
 export declare function getOptimumStopAndRisk(app_config: AppConfig, params: {
 	max_size: number;
 	target_stop: number;
 	highest_risk?: number;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }): {
 	optimal_stop: number;
 	optimal_risk: number;
@@ -1051,26 +1530,82 @@ export declare function generateOptimumAppConfig(config: GlobalConfig, payload:
 	risk_reward: number;
 	start_risk: number;
 	max_risk?: number;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: 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 | {
+export declare function determineOptimumReward(payload: {
+	app_config: AppConfig;
+	increase?: boolean;
+	low_range?: number;
+	high_range?: number;
+	target_loss?: number;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+	max_size?: number;
+}): number | {
 	result: any[];
 	value: number;
 	total: number;
 	risk_per_trade: number;
 	max: number;
 	min: number;
+	avg_size: any;
 	neg_pnl: any;
 	entry: any;
 };
+export declare function determineOptimumRisk(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	risk: number;
+	symbol: string;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+}, params: {
+	highest_risk: number;
+	tolerance?: number;
+	max_iterations?: number;
+}): {
+	optimal_risk: number;
+	achieved_neg_pnl: number;
+	target_neg_pnl: number;
+	difference: number;
+	iterations: number;
+	converged: boolean;
+	last_value: any;
+	entries: any[];
+	app_config: AppConfig;
+};
 export declare function computeRiskReward(payload: {
 	app_config: AppConfig;
 	entry: number;
 	stop: number;
 	risk_per_trade: number;
+	target_loss?: number;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+	high_range?: number;
+	max_size?: number;
 }): number | {
 	result: any[];
 	value: number;
@@ -1078,6 +1613,7 @@ export declare function computeRiskReward(payload: {
 	risk_per_trade: number;
 	max: number;
 	min: number;
+	avg_size: any;
 	neg_pnl: any;
 	entry: any;
 };
@@ -1086,6 +1622,17 @@ export declare function getRiskReward(payload: {
 	stop: number;
 	risk: number;
 	global_config: GlobalConfig;
+	force_exact_risk?: boolean;
+	target_loss?: number;
+	max_size?: number;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+	risk_factor?: number;
+	high_range?: number;
 }): any;
 export declare function computeProfitDetail(payload: {
 	focus_position: {
@@ -1095,11 +1642,12 @@ export declare function computeProfitDetail(payload: {
 		avg_qty: number;
 		avg_price: number;
 	};
-	strategy: {
+	strategy?: {
 		reward_factor: number;
 		max_reward_factor: number;
 		risk: number;
 	};
+	pnl: number;
 	reduce_position?: {
 		kind: "long" | "short";
 		entry: number;
@@ -1116,11 +1664,13 @@ export declare function computeProfitDetail(payload: {
 			quantity: number;
 		};
 	};
+	full_ratio?: number;
 	price_places?: string;
 	decimal_places?: string;
 }): {
 	pnl: number;
 	loss: number;
+	full_loss: number;
 	original_pnl: number;
 	reward_factor: number;
 	profit_percent: number;
@@ -1139,40 +1689,656 @@ export declare function generateGapTp(payload: {
 		entry: number;
 		quantity: number;
 	};
+	risk?: number;
+	kind?: "long" | "short";
 	factor?: number;
+	sell_factor?: number;
 	price_places?: string;
 	decimal_places?: string;
 }): {
-	long_tp: number;
-	short_tp: number;
-	short_to_reduce: number;
-	long_to_reduce: number;
-	to_sell: {
+	profit_percent: {
+		long: number;
+		short: number;
+	};
+	risk: {
 		short: number;
 		long: number;
 	};
-	gap: number;
-	gap_loss: number;
+	take_profit: {
+		long: number;
+		short: number;
+	};
+	to_reduce: {
+		short: number;
+		long: number;
+	};
+	full_reduce: {
+		short: number;
+		long: number;
+	};
+	sell_quantity: {
+		short: number;
+		long: number;
+	};
+	gap: number;
+	gap_loss: number;
+};
+export declare function calculateFactorFromTakeProfit(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	knownTp: number;
+	tpType: "long" | "short";
+	price_places?: string;
+}): number;
+export declare function calculateFactorFromSellQuantity(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	knownSellQuantity: number;
+	sellType: "long" | "short";
+	sell_factor?: number;
+	price_places?: string;
+	decimal_places?: string;
+}): number;
+export declare function determineRewardFactor(payload: {
+	quantity: number;
+	avg_qty: number;
+	minimum_pnl: number;
+	risk: number;
+}): number;
+export type BotPosition = {
+	kind: "long" | "short";
+	entry: number;
+	quantity: number;
+	tp: {
+		price: number;
+	};
+};
+export declare function getHedgeZone(payload: {
+	symbol_config: GlobalConfig;
+	risk: number;
+	position: BotPosition;
+	reward_factor?: number;
+	risk_factor?: number;
+	support?: number;
+}): {
+	support: number;
+	resistance: number;
+	risk: number;
+	profit_percent: number;
+};
+export declare function getOptimumHedgeFactor(payload: {
+	target_support: number;
+	tolerance?: number;
+	max_iterations?: number;
+	min_factor?: number;
+	max_factor?: number;
+	symbol_config: GlobalConfig;
+	risk: number;
+	position: BotPosition;
+}): {
+	reward_factor: number;
+	achieved_support: number;
+	target_support: number;
+	difference: number;
+	iterations: number;
+	converged?: undefined;
+} | {
+	reward_factor: number;
+	achieved_support: number;
+	target_support: number;
+	difference: number;
+	iterations: number;
+	converged: boolean;
+};
+export type CType = {
+	next_order: number;
+	take_profit: number;
+};
+export declare function determineCompoundLongTrade(payload: {
+	focus_short_position: CType;
+	focus_long_position: CType;
+	shortConfig: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		symbol: string;
+		profit_percent: number;
+	};
+	rr?: number;
+	global_config: GlobalConfig;
+}): {
+	start_risk: number;
+	short_profit: number;
+	support: number;
+	resistance: number;
+	long_v: any;
+	profit_percent: number;
+	result: any;
+	short_max_size: any;
+};
+export declare function generateOppositeTradeConfig(payload: {
+	kind: "long" | "short";
+	entry: number;
+	quantity: number;
+	target_pnl: number;
+	global_config: GlobalConfig;
+	ratio?: number;
+}): {
+	entry: number;
+	stop: number;
+	risk: number;
+	risk_reward: number | {
+		result: any[];
+		value: number;
+		total: number;
+		risk_per_trade: number;
+		max: number;
+		min: number;
+		avg_size: any;
+		neg_pnl: any;
+		entry: any;
+	};
+};
+export declare function constructAppConfig(payload: {
+	account: PositionsView;
+	global_config: GlobalConfig;
+	kelly_config?: {
+		use_kelly: boolean;
+		kelly_confidence_factor: number;
+		kelly_minimum_risk: number;
+		kelly_prediction_model: string;
+	};
+	distribution_config?: {
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: 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;
+	last_value?: any;
+	max_quantity?: number;
+	kelly?: {
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+};
+export declare function generateDangerousConfig(payload: {
+	account: PositionsView;
+	global_config: GlobalConfig;
+	config: {
+		quantity: number;
+		stop: number;
+		entry: number;
+	};
+}): {
+	entry: number;
+	risk: number;
+	stop: number;
+	risk_reward: number | {
+		result: any[];
+		value: number;
+		total: number;
+		risk_per_trade: number;
+		max: number;
+		min: number;
+		avg_size: any;
+		neg_pnl: any;
+		entry: any;
+	};
+};
+export interface ComputedTrade {
+	entry: number;
+	quantity: number;
+	avg_size: number;
+	neg_pnl: number;
+	avg_entry: number;
+	stop: number;
+	reverse_avg_entry: number;
+	reverse_avg_quantity: number;
+	fee: number;
+}
+export type TradeConfig = {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	risk: number;
+	symbol: string;
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+};
+declare function constructAppConfig$1({ config, global_config, }: {
+	config: TradeConfig;
+	global_config: GlobalConfig;
+}): {
+	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;
+	last_value?: any;
+	max_quantity?: number;
+	kelly?: {
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+};
+declare function buildWithOptimumReward({ config, settings, global_config, force_exact, }: {
+	config: TradeConfig;
+	global_config: GlobalConfig;
+	settings: {
+		entry?: number;
+		stop?: number;
+		risk: number;
+		stop_ratio?: number;
+		risk_reward?: number;
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
+	};
+	force_exact?: boolean;
+}): {
+	trades: any[];
+	summary: {
+		entry: number;
+		stop: number;
+		risk: number;
+		risk_reward: any;
+		avg_entry: number;
+		avg_size: number;
+		first_entry: number;
+		pnl: number;
+		fee: number;
+		loss: number;
+		last_entry: number;
+		margin: number;
+	};
+	config: any;
+	stop_order: {
+		quantity: number;
+		price: number;
+	};
+	kind: string;
+};
+declare function generateOppositeOptimum({ config, global_config, settings, ratio, distribution, distribution_params, risk_factor, }: {
+	settings: {
+		entry: number;
+		stop: number;
+		risk: number;
+	};
+	config: TradeConfig;
+	global_config: GlobalConfig;
+	fee_percent?: number;
+	ratio?: number;
+	distribution?: any;
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+	risk_factor?: number;
+}): {
+	trades: any[];
+	summary: any;
+	config: {
+		entry: number;
+		stop: number;
+		risk: number;
+		distribution: any;
+		distribution_params: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
+		risk_factor: number;
+	};
+	kind: string;
+} | {
+	trades: any[];
+	summary: {
+		entry: number;
+		stop: number;
+		risk: number;
+		risk_reward: any;
+		avg_entry: number;
+		avg_size: number;
+		first_entry: number;
+		pnl: number;
+		fee: number;
+		loss: number;
+		last_entry: number;
+		defaultEntry: number;
+	};
+	config: any;
+	kind: string;
+};
+declare function increaseTradeHelper({ increase_qty, stop, config, global_config, style, entry, position, stop_ratio, distribution: default_distribution, distribution_params: default_distribution_params, }: {
+	position: {
+		entry: number;
+		quantity: number;
+	};
+	entry: number;
+	stop: number;
+	config: TradeConfig;
+	global_config: GlobalConfig;
+	increase_qty: number;
+	style: "minimum" | "optimum";
+	stop_ratio?: number;
+	distribution?: any;
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+}): {
+	trades: any[];
+	summary: any;
+	config: any;
+	kind: string;
+	current: {
+		trades: any[];
+		summary: {
+			first_entry: number;
+			last_entry: number;
+			quantity: number;
+			entry: number;
+			loss: number;
+			number_of_trades: number;
+			fee: number;
+			anchor_pnl: any;
+		};
+	};
+	stop_order?: undefined;
+} | {
+	trades: any[];
+	summary: {
+		entry: number;
+		stop: number;
+		risk: number;
+		risk_reward: any;
+		avg_entry: number;
+		avg_size: number;
+		first_entry: number;
+		pnl: number;
+		fee: number;
+		loss: number;
+		last_entry: number;
+		margin: number;
+	};
+	stop_order: {
+		quantity: number;
+		price: number;
+	};
+	config: any;
+	kind: string;
+	current: {
+		trades: any[];
+		summary: {
+			first_entry: number;
+			last_entry: number;
+			quantity: number;
+			entry: number;
+			loss: number;
+			number_of_trades: number;
+			fee: number;
+			anchor_pnl: any;
+		};
+	};
+};
+declare function generatePositionIncreaseTrade({ account, zoneAccount, ratio, config, global_config, style, distribution, distribution_params, }: {
+	style?: "optimum" | "minimum";
+	account: {
+		long: {
+			entry: number;
+			quantity: number;
+		};
+		short: {
+			entry: number;
+			quantity: number;
+		};
+	};
+	config: TradeConfig;
+	global_config: GlobalConfig;
+	zoneAccount: {
+		entry: number;
+		stop: number;
+	};
+	ratio?: number;
+	distribution?: any;
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
+}): {
+	trades: any[];
+	summary: any;
+	config: any;
+	kind: string;
+	current: {
+		trades: any[];
+		summary: {
+			first_entry: number;
+			last_entry: number;
+			quantity: number;
+			entry: number;
+			loss: number;
+			number_of_trades: number;
+			fee: number;
+			anchor_pnl: any;
+		};
+	};
+	stop_order?: undefined;
+} | {
+	trades: any[];
+	summary: {
+		entry: number;
+		stop: number;
+		risk: number;
+		risk_reward: any;
+		avg_entry: number;
+		avg_size: number;
+		first_entry: number;
+		pnl: number;
+		fee: number;
+		loss: number;
+		last_entry: number;
+		margin: number;
+	};
+	stop_order: {
+		quantity: number;
+		price: number;
+	};
+	config: any;
+	kind: string;
+	current: {
+		trades: any[];
+		summary: {
+			first_entry: number;
+			last_entry: number;
+			quantity: number;
+			entry: number;
+			loss: number;
+			number_of_trades: number;
+			fee: number;
+			anchor_pnl: any;
+		};
+	};
+};
+declare function determineHedgeTradeToPlace({ position, config, global_config, profit_risk, allowable_loss, }: {
+	position: {
+		entry: number;
+		quantity: number;
+		kind: "long" | "short";
+	};
+	config: TradeConfig;
+	global_config: GlobalConfig;
+	profit_risk?: number;
+	allowable_loss?: number;
+}): {
+	opposite: {
+		trades: any[];
+		summary: {
+			entry: number;
+			stop: number;
+			risk: number;
+			risk_reward: any;
+			avg_entry: number;
+			avg_size: number;
+			first_entry: number;
+			pnl: number;
+			fee: number;
+			loss: number;
+			last_entry: number;
+			margin: number;
+		};
+		config: any;
+		stop_order: {
+			quantity: number;
+			price: number;
+		};
+		kind: string;
+	};
+	take_profit: number;
+};
+export declare const compoundAPI: {
+	determineHedgeTradeToPlace: typeof determineHedgeTradeToPlace;
+	buildWithOptimumReward: typeof buildWithOptimumReward;
+	constructAppConfig: typeof constructAppConfig$1;
+	generateOppositeOptimum: typeof generateOppositeOptimum;
+	increaseTradeHelper: typeof increaseTradeHelper;
+	generatePositionIncreaseTrade: typeof generatePositionIncreaseTrade;
+};
+export type ExchangeOrder = {
+	symbol: string;
+	price: number;
+	quantity: number;
+	kind: "long" | "short";
+	side: "buy" | "sell";
+	stop: number;
+	order_id: string;
+	triggerPrice?: number;
 };
-declare class ExchangePosition {
+export declare class ExchangePosition {
 	exchange: BaseExchange;
 	exchange_account: ExchangeAccount$1;
 	private app_db;
 	private instance;
+	orders: {
+		entries: ExchangeOrder[];
+		stop_orders: ExchangeOrder[];
+		tp_orders: ExchangeOrder[];
+	};
 	constructor(payload: {
 		exchange: BaseExchange;
 		app_db: AppDatabase;
 		instance: PositionsView;
 		exchange_account: ExchangeAccount$1;
 		without_view?: PositionsView;
+		orders?: {
+			entries: any[];
+			stop_orders: any[];
+			tp_orders: any[];
+		};
 	});
+	get symbol_config(): SymbolConfig;
+	initialize(): Promise<void>;
+	getInstance(): PositionsView;
 	get symbol(): any;
 	get kind(): any;
-	get account(): any;
+	get account(): ExchangeAccount;
+	get compound(): CompoundInstance & {
+		amount_to_risk?: number;
+		profit_percent?: number;
+	};
+	getProxyForAccount(): Promise<HttpsProxyAgent<`http://${string}`> | SocksProxyAgent>;
 	cancelOrders(payload: {
 		limit?: boolean;
 		price?: number;
-	}): Promise<void | {
+		raw?: boolean;
+	}): Promise<any[] | {
 		success: boolean;
 		message: string;
 		exchange_result?: undefined;
@@ -1197,9 +2363,10 @@ declare class ExchangePosition {
 			profit_percent?: number;
 			place_tp?: boolean;
 			profit?: number;
+			reduce_ratio?: number;
 		};
 	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
-	updateTargetPnl(): Promise<number>;
+	updateTargetPnl(): Promise<any>;
 	updateConfigPnl(): Promise<void>;
 	triggerTradeFromConfig(payload: {
 		place?: boolean;
@@ -1208,8 +2375,11 @@ declare class ExchangePosition {
 		stop?: boolean;
 		use_current?: boolean;
 		ignore_config?: boolean;
+		risky?: boolean;
+		hedge?: boolean;
+		stop_ratio?: number;
 	}): Promise<any>;
-	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders", payload: {
+	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders" | "dangerous_entry_orders", payload: {
 		entry: number;
 		stop: number;
 		risk_reward: number;
@@ -1218,6 +2388,15 @@ declare class ExchangePosition {
 		update_db?: boolean;
 		raw?: boolean;
 		use_current?: boolean;
+		stop_percent?: number;
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
+		hedge?: boolean;
+		stop_ratio?: number;
 	}): Promise<any>;
 	buildAppConfig(payload: {
 		entry: number;
@@ -1227,6 +2406,17 @@ declare class ExchangePosition {
 		profit?: number;
 		update_db?: boolean;
 		profit_percent?: number;
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	}): Promise<AppConfig>;
 	placeConfigOrders(app_config: AppConfig, solution: {
 		risk_reward: number;
@@ -1237,6 +2427,18 @@ declare class ExchangePosition {
 		neg_pnl: number;
 		min_size: number;
 		symbol: string;
+		stop_percent?: number;
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	}, place?: boolean, skip_stop?: boolean): Promise<{
 		entry_orders: {
 			orders: {
@@ -1277,17 +2479,318 @@ declare class ExchangePosition {
 		tp?: boolean;
 		stop?: boolean;
 		raw?: boolean;
+		limit?: boolean;
 		cancel?: boolean;
 		ignore_config?: boolean;
+		risky?: boolean;
+		target_pnl?: number;
+		hedge?: boolean;
+		stop_ratio?: number;
+	}): Promise<any>;
+	placeStopLimit(payload: {
+		place?: boolean;
+		stop: number;
+		quantity?: number;
+	}): Promise<any>;
+	computeTargetPnl(payload: {
+		secondary: ExchangePosition;
+	}): Promise<number>;
+	runSimulation(payload: {
+		iterations?: number;
+		long_position: ExchangePosition;
+		short_position: ExchangePosition;
+		raw?: boolean;
+	}): Promise<Strategy | {
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: {
+			avg_entry: number;
+			avg_size: number;
+			loss: number;
+			stop: number;
+			stop_quantity: number;
+			re_entry_quantity: number;
+			initial_pnl: number;
+			tp: number;
+			incurred_loss: number;
+			pnl: number;
+			remaining_quantity: number;
+		};
+		short: {
+			avg_entry: number;
+			avg_size: number;
+			loss: number;
+			stop: number;
+			stop_quantity: number;
+			re_entry_quantity: number;
+			initial_pnl: number;
+			tp: number;
+			incurred_loss: number;
+			pnl: number;
+			remaining_quantity: number;
+		};
+	}[]>;
+	rawConfigUpdate(payload: any): Promise<void>;
+	/**
+	 * This method is used to place the opposite trade action
+	 */
+	placeOppositeTradeAction(payload: {
+		data: {
+			avg: {
+				quantity: number;
+				price: number;
+			};
+			entry: number;
+			stop: number;
+			risk_per_trade: number;
+			profit_percent: number;
+			risk_reward: number;
+		};
+	}): Promise<void>;
+	/**
+	 * Updates the risk configuration for an empty position using the next_risk value.
+	 * This implements progressive risk management where successful trades increase future risk tolerance.
+	 *
+	 * @param payload.symbol - The trading symbol (e.g., "BTCUSDT")
+	 * @param payload.kind - Position type: "long" or "short"
+	 * @returns Object indicating if update was successful with old/new risk values
+	 */
+	updateRiskOnEmpty(): Promise<{
+		updated: boolean;
+		symbol: any;
+		kind: any;
+		old_risk: number;
+		new_risk: number;
+		reason?: undefined;
+	} | {
+		updated: boolean;
+		symbol: any;
+		kind: any;
+		reason: string;
+		old_risk?: undefined;
+		new_risk?: undefined;
+	}>;
+	increasePositionAtStop(payload: {
+		place?: boolean;
+		price?: number;
+		quantity?: number;
+		increase?: boolean;
+		ratio_to_loose?: number;
+		reverse_position?: ExchangePosition;
+		increase_ratio?: number;
+	}): Promise<any>;
+	lockReduction({ pnl, place, pause_tp, }: {
+		pnl: number;
+		place?: boolean;
+		pause_tp?: boolean;
+	}): Promise<{
+		sell_ratio: number;
+		current_pnl: number;
+		profit_percent: number;
+		current_price: number;
+		notional_value: number;
+	}>;
+	placeSingleOrder(payload: {
+		long_position: ExchangePosition;
+		short_position: ExchangePosition;
+	}): Promise<string>;
+	placeMarketOrder(payload: {
+		quantity?: number;
+		close?: boolean;
+	}): Promise<void>;
+	generate_config_params(payload: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		with_trades?: boolean;
+	}): Promise<any>;
+	extrapolateConfig(payload: {
+		risk_reward?: number;
+		risk?: number;
+		kind?: "long" | "short";
+	}): Promise<any>;
+	build_short_order(): Promise<any>;
+	/**
+	 * This function builds a config for a symbol
+	 * @param payload
+	 * @returns
+	 */
+	buildConfigForSymbol(payload: {
+		risk: number;
+		risk_reward?: number;
+		as_config?: boolean;
+		with_trades?: boolean;
+	}): Promise<any>;
+	buildTrades(payload: {
+		risk?: number;
+	}): Promise<{
+		trades: any[];
+		max_size: any;
+		last_price: any;
+		total_size: number;
+		avg_entry: number;
+	}>;
+	tradeConfig(payload: {
+		override?: any;
+	}): Promise<AppConfig>;
+	getOrCreatePositionConfig(payload: {
+		risk?: number;
+		risk_reward?: number;
+	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
+	getOppositeConfig(payload: {
+		ratio?: number;
+	}): {
+		entry: number;
+		stop: number;
+		risk: number;
+		risk_reward: number | {
+			result: any[];
+			value: number;
+			total: number;
+			risk_per_trade: number;
+			max: number;
+			min: number;
+			avg_size: any;
+			neg_pnl: any;
+			entry: any;
+		};
+	};
+	getOptimumRiskReward(): Promise<number | {
+		result: any[];
+		value: number;
+		total: number;
+		risk_per_trade: number;
+		max: number;
+		min: number;
+		avg_size: any;
+		neg_pnl: any;
+		entry: any;
+	}>;
+	get appConfig(): {
+		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;
+		last_value?: any;
+		max_quantity?: number;
+		kelly?: {
+			use_kelly?: boolean;
+			kelly_confidence_factor?: number;
+			kelly_minimum_risk?: number;
+			kelly_prediction_model?: "exponential" | "normal" | "uniform";
+			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+		};
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
+	};
+	updateProfitPercentWithRisk(payload: {
+		focus_position: ExchangePosition;
+	}): Promise<{
+		profit_percent: number;
+		take_profit: number;
+		last_order: number;
+	}>;
+	getOrders(payload: {
+		type?: "limit" | "stop" | "tp";
+	}): {
+		symbol: any;
+		price: any;
+		quantity: any;
+		kind: any;
+		side: any;
+		stop: any;
+		order_id: any;
+		triggerPrice: any;
+		client_order_id: any;
+	}[];
+	cancelExchangeOrder(payload: {
+		type: "limit" | "stop" | "tp";
+		refresh?: boolean;
+	}): Promise<any>;
+	placeDangerousTrade(payload: {
+		entry: number;
+		quantity: number;
+		stop?: number;
+	}): {
+		entry: number;
+		risk: number;
+		stop: number;
+		risk_reward: number | {
+			result: any[];
+			value: number;
+			total: number;
+			risk_per_trade: number;
+			max: number;
+			min: number;
+			avg_size: any;
+			neg_pnl: any;
+			entry: any;
+		};
+	};
+	followStop(payload: {
+		focus_position: ExchangePosition;
+		fee_percent?: number;
+		place?: boolean;
 	}): Promise<any>;
+	get support(): SupportTable;
+	get linkedConfig(): ScheduledTrade;
+	get isActiveTrade(): {
+		config: ScheduledTrade;
+		condition: boolean;
+	};
+	updateCompound(payload?: {
+		place?: boolean;
+	}): Promise<{
+		support: number;
+		counter: number;
+		new_risk: number;
+		condition: boolean;
+		stop: number;
+	}>;
+	cleanOnActiveCompoundInstance(): Promise<void>;
 }
 declare class ExchangeAccount$1 {
-	private instance;
+	instance: {
+		owner: string;
+		exchange: string;
+	};
 	exchange: BaseExchange;
 	main_exchange?: BaseExchange;
 	private app_db;
-	private long_position?;
-	private short_position?;
+	long_position?: ExchangePosition;
+	short_position?: ExchangePosition;
+	raw_positions?: PositionsView[];
 	constructor(payload: ExchangeType, options: {
 		exchange: BaseExchange;
 		app_db: AppDatabase;
@@ -1306,8 +2809,8 @@ declare class ExchangeAccount$1 {
 	}): Promise<import("pocketbase").RecordModel>;
 	initializePositions(payload: {
 		symbol: string;
-		as_view?: boolean;
 		kind: "long" | "short";
+		update?: boolean;
 	}): Promise<ExchangePosition>;
 	getActiveAccount(payload: {
 		symbol: string;
@@ -1330,6 +2833,7 @@ declare class ExchangeAccount$1 {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	syncAccount(options: {
@@ -1343,9 +2847,9 @@ declare class ExchangeAccount$1 {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
-	getRunningInstanceFromDB(symbol: string): Promise<TradeBlockTracking>;
 	syncOrders(options: {
 		symbol: string;
 		kind?: "long" | "short";
@@ -1356,6 +2860,11 @@ declare class ExchangeAccount$1 {
 		kind: "long" | "short";
 		should_stop?: boolean;
 	}): Promise<import("pocketbase").RecordModel>;
+	getFocusPosition(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		update?: boolean;
+	}): Promise<ExchangePosition>;
 	cancelOrders(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -1363,7 +2872,8 @@ declare class ExchangeAccount$1 {
 		all?: boolean;
 		stop?: boolean;
 		limit?: boolean;
-	}): Promise<void | {
+		raw?: boolean;
+	}): Promise<any[] | {
 		success: boolean;
 		message: string;
 		exchange_result?: undefined;
@@ -1384,24 +2894,15 @@ declare class ExchangeAccount$1 {
 		orders: number[];
 	}): Promise<any>;
 	getBreakEvenPrice(payload: {
-		symbol: string;
-	}): Promise<{
-		price: number;
-		direction: string;
-	}>;
-	buildAppConfig(payload: {
-		entry: number;
-		stop: number;
-		risk_reward: number;
-		risk: number;
-		symbol: string;
-		profit?: number;
-		update_db?: boolean;
-		profit_percent?: number;
-	}): Promise<AppConfig>;
+		symbol: string;
+	}): Promise<{
+		price: number;
+		direction: string;
+	}>;
 	tradeConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
+		override?: any;
 	}): Promise<AppConfig>;
 	justInTimeProfit(payload: {
 		symbol: string;
@@ -1429,48 +2930,7 @@ declare class ExchangeAccount$1 {
 		total_size: number;
 		avg_entry: number;
 	}>;
-	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;
-		symbol: string;
-		cancel?: boolean;
-		place?: boolean;
-	}): Promise<any[]>;
-	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders", payload: {
+	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders" | "dangerous_entry_orders", payload: {
 		symbol: string;
 		entry: number;
 		stop: number;
@@ -1480,6 +2940,7 @@ declare class ExchangeAccount$1 {
 		update_db?: boolean;
 		raw?: boolean;
 		use_current?: boolean;
+		stop_percent?: number;
 	}): Promise<any>;
 	getOrCreatePositionConfig(payload: {
 		symbol: string;
@@ -1548,7 +3009,7 @@ declare class ExchangeAccount$1 {
 			not_reduce: boolean;
 			ratio: any;
 			use_full: boolean;
-			sell_ratio: any;
+			sell_ratio: number;
 		};
 		trigger: {
 			long: boolean;
@@ -1581,14 +3042,6 @@ declare class ExchangeAccount$1 {
 		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";
@@ -1602,12 +3055,29 @@ declare class ExchangeAccount$1 {
 	placeMarketOrder(payload: {
 		symbol: string;
 		kind: "long" | "short";
-		quantity: number;
+		quantity?: number;
+		close?: boolean;
 	}): Promise<void>;
 	placeSingleOrder(payload: {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<string>;
+	followStop(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		fee_percent?: number;
+		focus_position: ExchangePosition;
+		place?: boolean;
+	}): Promise<any>;
+	increasePositionAtStop(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+		price?: number;
+		quantity?: number;
+		increase?: boolean;
+		ratio_to_loose?: number;
+	}): Promise<any>;
 	triggerTradeFromConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -1617,6 +3087,7 @@ declare class ExchangeAccount$1 {
 		stop?: boolean;
 		use_current?: boolean;
 		ignore_config?: boolean;
+		risky?: boolean;
 	}): Promise<any>;
 	verifyStopLoss(payload: {
 		symbol: string;
@@ -1631,7 +3102,46 @@ declare class ExchangeAccount$1 {
 	updateTargetPnl(payload: {
 		symbol: string;
 		kind: "long" | "short";
-	}): Promise<number>;
+	}): Promise<any>;
+	updateRiskOnEmpty(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<{
+		updated: boolean;
+		symbol: any;
+		kind: any;
+		old_risk: number;
+		new_risk: number;
+		reason?: undefined;
+	} | {
+		updated: boolean;
+		symbol: any;
+		kind: any;
+		reason: string;
+		old_risk?: undefined;
+		new_risk?: undefined;
+	}>;
+	updateGoodHedgeConfig(payload: {
+		symbol: string;
+		params?: {
+			support: number;
+			resistance: number;
+			risk: number;
+			profit_percent: number;
+		};
+		risk_factor?: number;
+		update?: boolean;
+		place?: boolean;
+		update_tp?: boolean;
+	}): Promise<{
+		support: number;
+		resistance: number;
+		risk: number;
+		profit_percent: number;
+	}>;
+	/**
+	 * This method is used to place the opposite trade action
+	 */
 	placeOppositeTradeAction(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -1684,6 +3194,20 @@ declare class ExchangeAccount$1 {
 		gap?: number;
 		rr?: number;
 		max_size?: number;
+		max_quantity?: number;
+		kelly?: {
+			use_kelly?: boolean;
+			kelly_confidence_factor?: number;
+			kelly_minimum_risk?: number;
+			kelly_prediction_model?: "exponential" | "normal" | "uniform";
+			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+		};
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	}>;
 	runSimulation(payload: {
 		symbol: string;
@@ -1785,6 +3309,37 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	placeStopLimit(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+		stop: number;
+		quantity?: number;
+	}): Promise<any>;
+	placeDangerousTrade(payload: {
+		symbol: string;
+		config: {
+			entry: number;
+			quantity: number;
+			stop: number;
+		};
+		kind: "long" | "short";
+	}): Promise<{
+		entry: number;
+		risk: number;
+		stop: number;
+		risk_reward: number | {
+			result: any[];
+			value: number;
+			total: number;
+			risk_per_trade: number;
+			max: number;
+			min: number;
+			avg_size: any;
+			neg_pnl: any;
+			entry: any;
+		};
+	}>;
 	placeTrade(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -1796,6 +3351,7 @@ declare class ExchangeAccount$1 {
 		cancel?: boolean;
 		ignore_config?: boolean;
 		target_pnl?: number;
+		risky?: boolean;
 	}): Promise<any>;
 	updateConfigPnl(payload: {
 		symbol: string;
@@ -1814,57 +3370,18 @@ declare class ExchangeAccount$1 {
 		long_percent: number;
 		short_percent: number;
 	}>;
+	oppositeGapExists(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<void>;
 	profitWithinGapStrategy(payload: {
 		symbol: string;
-	}): Promise<{
-		reverse_config: any;
-		reverse_action: {
-			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;
+		callback?: (params: {
+			symbol: string;
+			account: ExchangeType;
 			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;
-		};
-		reverse_orders_to_buy: any;
-		positions: {
-			long: PositionsView & {
-				expand?: {
-					account_strategy?: AccountStrategy;
-				};
-			};
-			short: PositionsView & {
-				expand?: {
-					account_strategy?: AccountStrategy;
-				};
-			};
-		};
-		orders_to_place: any;
+		}) => Promise<any>;
+	}): Promise<{
 		config_details: {
 			app_config: {
 				fee: number;
@@ -1891,36 +3408,49 @@ declare class ExchangeAccount$1 {
 				gap?: number;
 				rr?: number;
 				max_size?: number;
-			};
-			last_value: any;
-			config: {
-				entry: number;
-				stop: number;
-				risk: number;
-				risk_reward: number | {
-					result: any[];
-					value: number;
-					total: number;
-					risk_per_trade: number;
-					max: number;
-					min: number;
-					neg_pnl: any;
-					entry: any;
+				max_quantity?: number;
+				kelly?: {
+					use_kelly?: boolean;
+					kelly_confidence_factor?: number;
+					kelly_minimum_risk?: number;
+					kelly_prediction_model?: "exponential" | "normal" | "uniform";
+					kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+				};
+				distribution?: GetEntriesParams["distribution"];
+				distribution_params?: {
+					curveFactor?: number;
+					stdDevFactor?: number;
+					lambda?: number;
 				};
-				profit_percent: number;
 			};
-			pnl: number;
+			last_value: any;
 		};
 	}>;
 	generateGapTp(payload: {
 		symbol: string;
 		factor?: number;
 	}): Promise<{
-		long_tp: number;
-		short_tp: number;
-		short_to_reduce: number;
-		long_to_reduce: number;
-		to_sell: {
+		profit_percent: {
+			long: number;
+			short: number;
+		};
+		risk: {
+			short: number;
+			long: number;
+		};
+		take_profit: {
+			long: number;
+			short: number;
+		};
+		to_reduce: {
+			short: number;
+			long: number;
+		};
+		full_reduce: {
+			short: number;
+			long: number;
+		};
+		sell_quantity: {
 			short: number;
 			long: number;
 		};
@@ -1930,9 +3460,12 @@ declare class ExchangeAccount$1 {
 	getSellPriceFromStrategy(payload: {
 		symbol: string;
 		reduce_position: PositionsView;
+		kind?: "long" | "short";
+		full_ratio?: number;
 	}): Promise<{
 		pnl: number;
 		loss: number;
+		full_loss: number;
 		original_pnl: number;
 		reward_factor: number;
 		profit_percent: number;
@@ -1942,15 +3475,43 @@ declare class ExchangeAccount$1 {
 		price_places: string;
 		decimal_places: string;
 	}>;
+	placeCompoundShortTrade(payload: {}): Promise<void>;
+	placeCompoundLongTrade(payload: {
+		symbol: string;
+		params: {
+			resistance: number;
+			support: number;
+			profit_percent: number;
+			risk_reward: number;
+			risk: number;
+		};
+		place?: boolean;
+	}): Promise<void>;
+	getConfigProfiles(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<{
+		id: any;
+		entry: any;
+		stop: any;
+		kind: "long" | "short";
+		risk_reward: any;
+		risk: any;
+		profit_percent: any;
+	}[]>;
 }
 declare function getExchangeAccount(payload: {
 	account: ExchangeType;
 	app_db: AppDatabase;
-	getCredentials: (account: string, exchange: string) => {
+	getCredentials: (payload: {
+		account: string;
+		exchange: string;
+		app_db: AppDatabase;
+	}) => Promise<{
 		api_key: string;
 		api_secret: string;
 		email: string;
-	};
+	}>;
 	proxyOptions?: {
 		proxy?: any;
 		ignore_proxy?: boolean;
@@ -1965,11 +3526,14 @@ declare class App {
 		canWithdraw?: boolean;
 	};
 	private getCredentials;
-	constructor(app_db: AppDatabase, getCredentials: (account: string, exchange: string) => {
+	constructor(app_db: AppDatabase, getCredentials: (payload: {
+		account: string;
+		exchange: string;
+	}) => Promise<{
 		api_key: string;
 		api_secret: string;
 		email: string;
-	}, proxyOptions?: {
+	}>, proxyOptions?: {
 		proxy?: any;
 		ignore_proxy?: boolean;
 		canWithdraw?: boolean;
@@ -1985,13 +3549,14 @@ declare class App {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	syncOrders(payload: {
 		account: ExchangeType;
 		symbol: string;
 		kind: "long" | "short";
-	}): Promise<any>;
+	}): Promise<boolean>;
 	cancelOrders(payload: {
 		account: ExchangeType;
 		symbol: string;
@@ -1999,7 +3564,7 @@ declare class App {
 		price?: number;
 		all?: boolean;
 		stop?: boolean;
-	}): Promise<void | {
+	}): Promise<any[] | {
 		success: boolean;
 		message: string;
 		exchange_result?: undefined;
@@ -2038,10 +3603,16 @@ declare class App {
 	getNonEssentialSymbols(): Promise<Set<any>>;
 	refreshAllPositionsWithSymbol(payload: {
 		symbol: string;
+		callback?: (payload: {
+			symbol: string;
+			account: ExchangeType;
+		}) => Promise<any>;
 	}): Promise<void>;
 	autoFollowPositions(): Promise<void>;
 	getMoverExchangeInstances(): Promise<ExchangeAccount[]>;
-	updateTpOnAllMarkets(): Promise<void>;
+	updateTpOnAllMarkets(callback?: (payload: {
+		account: ExchangeType;
+	}) => Promise<any>): Promise<void>;
 	triggerMoverTask(payload: {
 		callback: (params: {
 			symbol: string;
@@ -2061,62 +3632,21 @@ declare class App {
 		cancel?: boolean;
 		raw?: boolean;
 	}): Promise<any>;
-	runDbStrategyAccounts(callback: (params: {
-		symbol: string;
-		account: ExchangeType;
-	}) => Promise<any>): Promise<void>;
+	runDbStrategyAccounts(payload: {
+		runningCallback: (params: {
+			symbol: string;
+			account: ExchangeType;
+		}) => Promise<any>;
+		notRunningCallback: (params: {
+			symbol: string;
+			account: ExchangeType;
+			kind: "long" | "short";
+		}) => Promise<any>;
+	}): Promise<void>;
 	profitWithinGapStrategy(payload: {
 		account: ExchangeType;
 		symbol: string;
 	}): Promise<{
-		reverse_config: any;
-		reverse_action: {
-			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;
-		};
-		reverse_orders_to_buy: any;
-		positions: {
-			long: PositionsView & {
-				expand?: {
-					account_strategy?: AccountStrategy;
-				};
-			};
-			short: PositionsView & {
-				expand?: {
-					account_strategy?: AccountStrategy;
-				};
-			};
-		};
-		orders_to_place: any;
 		config_details: {
 			app_config: {
 				fee: number;
@@ -2143,30 +3673,47 @@ declare class App {
 				gap?: number;
 				rr?: number;
 				max_size?: number;
-			};
-			last_value: any;
-			config: {
-				entry: number;
-				stop: number;
-				risk: number;
-				risk_reward: number | {
-					result: any[];
-					value: number;
-					total: number;
-					risk_per_trade: number;
-					max: number;
-					min: number;
-					neg_pnl: any;
-					entry: any;
+				max_quantity?: number;
+				kelly?: {
+					use_kelly?: boolean;
+					kelly_confidence_factor?: number;
+					kelly_minimum_risk?: number;
+					kelly_prediction_model?: "exponential" | "normal" | "uniform";
+					kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
+				};
+				distribution?: GetEntriesParams["distribution"];
+				distribution_params?: {
+					curveFactor?: number;
+					stdDevFactor?: number;
+					lambda?: number;
 				};
-				profit_percent: number;
 			};
-			pnl: number;
+			last_value: any;
+		};
+	}>;
+	compoundLongTrade(payload: {
+		main_account: ExchangeType & {
+			symbol: string;
+		};
+		focus_account: ExchangeType & {
+			symbol: string;
 		};
+		place?: boolean;
+		rr?: number;
+	}): Promise<{
+		start_risk: number;
+		short_profit: number;
+		support: number;
+		resistance: number;
+		long_v: any;
+		profit_percent: number;
+		result: any;
+		short_max_size: any;
 	}>;
 	reduceExistingPosition(payload: {
 		main_account: ExchangeType & {
 			symbol: string;
+			kind?: "long" | "short";
 		};
 		reduce_account: ExchangeType & {
 			symbol: string;
@@ -2174,6 +3721,8 @@ declare class App {
 		kind: "long" | "short";
 		place?: boolean;
 		increase?: boolean;
+		full_ratio?: number;
+		cancel_limit?: boolean;
 	}): Promise<any>;
 }
 export declare function initApp(payload: {
@@ -2183,21 +3732,27 @@ export declare function initApp(payload: {
 		password: string;
 	};
 	password?: string;
-	getCredentials: (account: string, exchange: string) => {
+	salt?: string;
+	email?: string;
+	getCredentials: (payload: {
+		account: string;
+		exchange: string;
+		app_db: AppDatabase;
+	}) => Promise<{
 		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;
-};
+declare function getCredentials(payload: {
+	account: string;
+	exchange: string;
+	app_db: AppDatabase;
+}): Promise<any>;
 export declare function initialize(payload: {
 	password?: string;
 	proxy?: any;
@@ -2206,7 +3761,7 @@ export declare function initialize(payload: {
 }): Promise<App>;
 
 declare namespace database {
-	export { AppDatabase, ExchangeType, initPocketBaseClient };
+	export { AppDatabase, ExchangeType, decryptObject, encryptObject, initPocketBaseClient };
 }
 declare namespace exchange_account {
 	export { ExchangeAccount$1 as ExchangeAccount, getExchangeAccount };