import { z } from 'zod';
export declare enum TradeInputOrderType {
    MARKET = "market",
    STOP_LIMIT = "stop_limit",
    LIMIT = "limit",
    MARKET_ZERO_FEE = "market_zero_fee"
}
export declare enum MarginUpdateType {
    DEPOSIT = 0,
    WITHDRAW = 1
}
export declare const SpreadSchema: z.ZodObject<{
    min: z.ZodNumber;
    max: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    min: number;
    max: number;
}, {
    min: number;
    max: number;
}>;
export declare const PairInfoSchema: z.ZodObject<{
    from: z.ZodString;
    to: z.ZodString;
    spread: z.ZodObject<{
        min: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        min: number;
        max: number;
    }, {
        min: number;
        max: number;
    }>;
    groupIndex: z.ZodNumber;
    feeIndex: z.ZodNumber;
    maxLeverage: z.ZodNumber;
    maxLongOiP: z.ZodNumber;
    maxShortOiP: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    from: string;
    to: string;
    maxLeverage: number;
    groupIndex: number;
    feeIndex: number;
    maxLongOiP: number;
    maxShortOiP: number;
    spread: {
        min: number;
        max: number;
    };
}, {
    from: string;
    to: string;
    maxLeverage: number;
    groupIndex: number;
    feeIndex: number;
    maxLongOiP: number;
    maxShortOiP: number;
    spread: {
        min: number;
        max: number;
    };
}>;
export declare const TradeInputSchema: z.ZodObject<{
    pair: z.ZodString;
    isLong: z.ZodBoolean;
    collateralInTrade: z.ZodNumber;
    leverage: z.ZodNumber;
    openPrice: z.ZodNumber;
    tp: z.ZodNumber;
    sl: z.ZodNumber;
    referrer: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    orderType: z.ZodNativeEnum<typeof TradeInputOrderType>;
    maxSlippageP: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    referrer: string;
    openPrice: number;
    leverage: number;
    tp: number;
    sl: number;
    orderType: TradeInputOrderType;
    pair: string;
    isLong: boolean;
    collateralInTrade: number;
    maxSlippageP: number;
}, {
    openPrice: number;
    leverage: number;
    tp: number;
    sl: number;
    orderType: TradeInputOrderType;
    pair: string;
    isLong: boolean;
    collateralInTrade: number;
    maxSlippageP: number;
    referrer?: string | undefined;
}>;
export declare const TradeResponseSchema: z.ZodObject<{
    trader: z.ZodString;
    pairIndex: z.ZodNumber;
    index: z.ZodNumber;
    initialPosUsdc: z.ZodNumber;
    openPrice: z.ZodNumber;
    buy: z.ZodBoolean;
    leverage: z.ZodNumber;
    tp: z.ZodNumber;
    sl: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    trader: string;
    pairIndex: number;
    index: number;
    openPrice: number;
    buy: boolean;
    leverage: number;
    tp: number;
    sl: number;
    initialPosUsdc: number;
}, {
    trader: string;
    pairIndex: number;
    index: number;
    openPrice: number;
    buy: boolean;
    leverage: number;
    tp: number;
    sl: number;
    initialPosUsdc: number;
}>;
export declare const PriceSchema: z.ZodObject<{
    price: z.ZodString;
    conf: z.ZodString;
    expo: z.ZodNumber;
    publishTime: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    price: string;
    conf: string;
    expo: number;
    publishTime: number;
}, {
    price: string;
    conf: string;
    expo: number;
    publishTime: number;
}>;
export declare const EmaPriceSchema: z.ZodObject<{
    price: z.ZodString;
    conf: z.ZodString;
    expo: z.ZodNumber;
    publishTime: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    price: string;
    conf: string;
    expo: number;
    publishTime: number;
}, {
    price: string;
    conf: string;
    expo: number;
    publishTime: number;
}>;
export declare const PriceFeedResponseSchema: z.ZodObject<{
    id: z.ZodString;
    price: z.ZodObject<{
        price: z.ZodString;
        conf: z.ZodString;
        expo: z.ZodNumber;
        publishTime: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    }, {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    }>;
    emaPrice: z.ZodObject<{
        price: z.ZodString;
        conf: z.ZodString;
        expo: z.ZodNumber;
        publishTime: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    }, {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    }>;
}, "strip", z.ZodTypeAny, {
    id: string;
    price: {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    };
    emaPrice: {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    };
}, {
    id: string;
    price: {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    };
    emaPrice: {
        price: string;
        conf: string;
        expo: number;
        publishTime: number;
    };
}>;
export declare const OpenInterestSchema: z.ZodObject<{
    long: z.ZodNumber;
    short: z.ZodNumber;
    max: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    long: number;
    max: number;
    short: number;
}, {
    long: number;
    max: number;
    short: number;
}>;
export declare const OpenInterestLimitsSchema: z.ZodObject<{
    pairIndex: z.ZodNumber;
    maxLong: z.ZodNumber;
    maxShort: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    pairIndex: number;
    maxLong: number;
    maxShort: number;
}, {
    pairIndex: number;
    maxLong: number;
    maxShort: number;
}>;
export declare const UtilizationSchema: z.ZodObject<{
    utilizationLong: z.ZodNumber;
    utilizationShort: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    utilizationLong: number;
    utilizationShort: number;
}, {
    utilizationLong: number;
    utilizationShort: number;
}>;
export declare const SkewSchema: z.ZodObject<{
    skew: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    skew: number;
}, {
    skew: number;
}>;
export declare const FeeSchema: z.ZodObject<{
    feeP: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    feeP: number;
}, {
    feeP: number;
}>;
export declare const DepthSchema: z.ZodObject<{
    onePercentDepthAboveUsdc: z.ZodNumber;
    onePercentDepthBelowUsdc: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    onePercentDepthAboveUsdc: number;
    onePercentDepthBelowUsdc: number;
}, {
    onePercentDepthAboveUsdc: number;
    onePercentDepthBelowUsdc: number;
}>;
export declare const LossProtectionInfoSchema: z.ZodObject<{
    tier: z.ZodNumber;
    percentage: z.ZodNumber;
    amount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    tier: number;
    amount: number;
    percentage: number;
}, {
    tier: number;
    amount: number;
    percentage: number;
}>;
export declare const PairDataSchema: z.ZodObject<{
    pairInfo: z.ZodObject<{
        from: z.ZodString;
        to: z.ZodString;
        spread: z.ZodObject<{
            min: z.ZodNumber;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            min: number;
            max: number;
        }, {
            min: number;
            max: number;
        }>;
        groupIndex: z.ZodNumber;
        feeIndex: z.ZodNumber;
        maxLeverage: z.ZodNumber;
        maxLongOiP: z.ZodNumber;
        maxShortOiP: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        from: string;
        to: string;
        maxLeverage: number;
        groupIndex: number;
        feeIndex: number;
        maxLongOiP: number;
        maxShortOiP: number;
        spread: {
            min: number;
            max: number;
        };
    }, {
        from: string;
        to: string;
        maxLeverage: number;
        groupIndex: number;
        feeIndex: number;
        maxLongOiP: number;
        maxShortOiP: number;
        spread: {
            min: number;
            max: number;
        };
    }>;
    openInterest: z.ZodOptional<z.ZodObject<{
        long: z.ZodNumber;
        short: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        long: number;
        max: number;
        short: number;
    }, {
        long: number;
        max: number;
        short: number;
    }>>;
    utilization: z.ZodOptional<z.ZodObject<{
        utilizationLong: z.ZodNumber;
        utilizationShort: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        utilizationLong: number;
        utilizationShort: number;
    }, {
        utilizationLong: number;
        utilizationShort: number;
    }>>;
    skew: z.ZodOptional<z.ZodObject<{
        skew: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        skew: number;
    }, {
        skew: number;
    }>>;
    fee: z.ZodOptional<z.ZodObject<{
        feeP: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        feeP: number;
    }, {
        feeP: number;
    }>>;
    depth: z.ZodOptional<z.ZodObject<{
        onePercentDepthAboveUsdc: z.ZodNumber;
        onePercentDepthBelowUsdc: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        onePercentDepthAboveUsdc: number;
        onePercentDepthBelowUsdc: number;
    }, {
        onePercentDepthAboveUsdc: number;
        onePercentDepthBelowUsdc: number;
    }>>;
    spread: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    pairInfo: {
        from: string;
        to: string;
        maxLeverage: number;
        groupIndex: number;
        feeIndex: number;
        maxLongOiP: number;
        maxShortOiP: number;
        spread: {
            min: number;
            max: number;
        };
    };
    fee?: {
        feeP: number;
    } | undefined;
    spread?: number | undefined;
    skew?: {
        skew: number;
    } | undefined;
    openInterest?: {
        long: number;
        max: number;
        short: number;
    } | undefined;
    utilization?: {
        utilizationLong: number;
        utilizationShort: number;
    } | undefined;
    depth?: {
        onePercentDepthAboveUsdc: number;
        onePercentDepthBelowUsdc: number;
    } | undefined;
}, {
    pairInfo: {
        from: string;
        to: string;
        maxLeverage: number;
        groupIndex: number;
        feeIndex: number;
        maxLongOiP: number;
        maxShortOiP: number;
        spread: {
            min: number;
            max: number;
        };
    };
    fee?: {
        feeP: number;
    } | undefined;
    spread?: number | undefined;
    skew?: {
        skew: number;
    } | undefined;
    openInterest?: {
        long: number;
        max: number;
        short: number;
    } | undefined;
    utilization?: {
        utilizationLong: number;
        utilizationShort: number;
    } | undefined;
    depth?: {
        onePercentDepthAboveUsdc: number;
        onePercentDepthBelowUsdc: number;
    } | undefined;
}>;
export declare const GroupSchema: z.ZodObject<{
    groupIndex: z.ZodNumber;
    pairs: z.ZodRecord<z.ZodString, z.ZodObject<{
        pairInfo: z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            spread: z.ZodObject<{
                min: z.ZodNumber;
                max: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                min: number;
                max: number;
            }, {
                min: number;
                max: number;
            }>;
            groupIndex: z.ZodNumber;
            feeIndex: z.ZodNumber;
            maxLeverage: z.ZodNumber;
            maxLongOiP: z.ZodNumber;
            maxShortOiP: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            from: string;
            to: string;
            maxLeverage: number;
            groupIndex: number;
            feeIndex: number;
            maxLongOiP: number;
            maxShortOiP: number;
            spread: {
                min: number;
                max: number;
            };
        }, {
            from: string;
            to: string;
            maxLeverage: number;
            groupIndex: number;
            feeIndex: number;
            maxLongOiP: number;
            maxShortOiP: number;
            spread: {
                min: number;
                max: number;
            };
        }>;
        openInterest: z.ZodOptional<z.ZodObject<{
            long: z.ZodNumber;
            short: z.ZodNumber;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            long: number;
            max: number;
            short: number;
        }, {
            long: number;
            max: number;
            short: number;
        }>>;
        utilization: z.ZodOptional<z.ZodObject<{
            utilizationLong: z.ZodNumber;
            utilizationShort: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            utilizationLong: number;
            utilizationShort: number;
        }, {
            utilizationLong: number;
            utilizationShort: number;
        }>>;
        skew: z.ZodOptional<z.ZodObject<{
            skew: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            skew: number;
        }, {
            skew: number;
        }>>;
        fee: z.ZodOptional<z.ZodObject<{
            feeP: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            feeP: number;
        }, {
            feeP: number;
        }>>;
        depth: z.ZodOptional<z.ZodObject<{
            onePercentDepthAboveUsdc: z.ZodNumber;
            onePercentDepthBelowUsdc: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            onePercentDepthAboveUsdc: number;
            onePercentDepthBelowUsdc: number;
        }, {
            onePercentDepthAboveUsdc: number;
            onePercentDepthBelowUsdc: number;
        }>>;
        spread: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        pairInfo: {
            from: string;
            to: string;
            maxLeverage: number;
            groupIndex: number;
            feeIndex: number;
            maxLongOiP: number;
            maxShortOiP: number;
            spread: {
                min: number;
                max: number;
            };
        };
        fee?: {
            feeP: number;
        } | undefined;
        spread?: number | undefined;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
        depth?: {
            onePercentDepthAboveUsdc: number;
            onePercentDepthBelowUsdc: number;
        } | undefined;
    }, {
        pairInfo: {
            from: string;
            to: string;
            maxLeverage: number;
            groupIndex: number;
            feeIndex: number;
            maxLongOiP: number;
            maxShortOiP: number;
            spread: {
                min: number;
                max: number;
            };
        };
        fee?: {
            feeP: number;
        } | undefined;
        spread?: number | undefined;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
        depth?: {
            onePercentDepthAboveUsdc: number;
            onePercentDepthBelowUsdc: number;
        } | undefined;
    }>>;
    openInterest: z.ZodOptional<z.ZodObject<{
        long: z.ZodNumber;
        short: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        long: number;
        max: number;
        short: number;
    }, {
        long: number;
        max: number;
        short: number;
    }>>;
    utilization: z.ZodOptional<z.ZodObject<{
        utilizationLong: z.ZodNumber;
        utilizationShort: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        utilizationLong: number;
        utilizationShort: number;
    }, {
        utilizationLong: number;
        utilizationShort: number;
    }>>;
    skew: z.ZodOptional<z.ZodObject<{
        skew: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        skew: number;
    }, {
        skew: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    groupIndex: number;
    pairs: Record<string, {
        pairInfo: {
            from: string;
            to: string;
            maxLeverage: number;
            groupIndex: number;
            feeIndex: number;
            maxLongOiP: number;
            maxShortOiP: number;
            spread: {
                min: number;
                max: number;
            };
        };
        fee?: {
            feeP: number;
        } | undefined;
        spread?: number | undefined;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
        depth?: {
            onePercentDepthAboveUsdc: number;
            onePercentDepthBelowUsdc: number;
        } | undefined;
    }>;
    skew?: {
        skew: number;
    } | undefined;
    openInterest?: {
        long: number;
        max: number;
        short: number;
    } | undefined;
    utilization?: {
        utilizationLong: number;
        utilizationShort: number;
    } | undefined;
}, {
    groupIndex: number;
    pairs: Record<string, {
        pairInfo: {
            from: string;
            to: string;
            maxLeverage: number;
            groupIndex: number;
            feeIndex: number;
            maxLongOiP: number;
            maxShortOiP: number;
            spread: {
                min: number;
                max: number;
            };
        };
        fee?: {
            feeP: number;
        } | undefined;
        spread?: number | undefined;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
        depth?: {
            onePercentDepthAboveUsdc: number;
            onePercentDepthBelowUsdc: number;
        } | undefined;
    }>;
    skew?: {
        skew: number;
    } | undefined;
    openInterest?: {
        long: number;
        max: number;
        short: number;
    } | undefined;
    utilization?: {
        utilizationLong: number;
        utilizationShort: number;
    } | undefined;
}>;
export declare const SnapshotSchema: z.ZodObject<{
    groups: z.ZodRecord<z.ZodString, z.ZodObject<{
        groupIndex: z.ZodNumber;
        pairs: z.ZodRecord<z.ZodString, z.ZodObject<{
            pairInfo: z.ZodObject<{
                from: z.ZodString;
                to: z.ZodString;
                spread: z.ZodObject<{
                    min: z.ZodNumber;
                    max: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    min: number;
                    max: number;
                }, {
                    min: number;
                    max: number;
                }>;
                groupIndex: z.ZodNumber;
                feeIndex: z.ZodNumber;
                maxLeverage: z.ZodNumber;
                maxLongOiP: z.ZodNumber;
                maxShortOiP: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            }, {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            }>;
            openInterest: z.ZodOptional<z.ZodObject<{
                long: z.ZodNumber;
                short: z.ZodNumber;
                max: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                long: number;
                max: number;
                short: number;
            }, {
                long: number;
                max: number;
                short: number;
            }>>;
            utilization: z.ZodOptional<z.ZodObject<{
                utilizationLong: z.ZodNumber;
                utilizationShort: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                utilizationLong: number;
                utilizationShort: number;
            }, {
                utilizationLong: number;
                utilizationShort: number;
            }>>;
            skew: z.ZodOptional<z.ZodObject<{
                skew: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                skew: number;
            }, {
                skew: number;
            }>>;
            fee: z.ZodOptional<z.ZodObject<{
                feeP: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                feeP: number;
            }, {
                feeP: number;
            }>>;
            depth: z.ZodOptional<z.ZodObject<{
                onePercentDepthAboveUsdc: z.ZodNumber;
                onePercentDepthBelowUsdc: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            }, {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            }>>;
            spread: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            pairInfo: {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            };
            fee?: {
                feeP: number;
            } | undefined;
            spread?: number | undefined;
            skew?: {
                skew: number;
            } | undefined;
            openInterest?: {
                long: number;
                max: number;
                short: number;
            } | undefined;
            utilization?: {
                utilizationLong: number;
                utilizationShort: number;
            } | undefined;
            depth?: {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            } | undefined;
        }, {
            pairInfo: {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            };
            fee?: {
                feeP: number;
            } | undefined;
            spread?: number | undefined;
            skew?: {
                skew: number;
            } | undefined;
            openInterest?: {
                long: number;
                max: number;
                short: number;
            } | undefined;
            utilization?: {
                utilizationLong: number;
                utilizationShort: number;
            } | undefined;
            depth?: {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            } | undefined;
        }>>;
        openInterest: z.ZodOptional<z.ZodObject<{
            long: z.ZodNumber;
            short: z.ZodNumber;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            long: number;
            max: number;
            short: number;
        }, {
            long: number;
            max: number;
            short: number;
        }>>;
        utilization: z.ZodOptional<z.ZodObject<{
            utilizationLong: z.ZodNumber;
            utilizationShort: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            utilizationLong: number;
            utilizationShort: number;
        }, {
            utilizationLong: number;
            utilizationShort: number;
        }>>;
        skew: z.ZodOptional<z.ZodObject<{
            skew: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            skew: number;
        }, {
            skew: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        groupIndex: number;
        pairs: Record<string, {
            pairInfo: {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            };
            fee?: {
                feeP: number;
            } | undefined;
            spread?: number | undefined;
            skew?: {
                skew: number;
            } | undefined;
            openInterest?: {
                long: number;
                max: number;
                short: number;
            } | undefined;
            utilization?: {
                utilizationLong: number;
                utilizationShort: number;
            } | undefined;
            depth?: {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            } | undefined;
        }>;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
    }, {
        groupIndex: number;
        pairs: Record<string, {
            pairInfo: {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            };
            fee?: {
                feeP: number;
            } | undefined;
            spread?: number | undefined;
            skew?: {
                skew: number;
            } | undefined;
            openInterest?: {
                long: number;
                max: number;
                short: number;
            } | undefined;
            utilization?: {
                utilizationLong: number;
                utilizationShort: number;
            } | undefined;
            depth?: {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            } | undefined;
        }>;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    groups: Record<string, {
        groupIndex: number;
        pairs: Record<string, {
            pairInfo: {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            };
            fee?: {
                feeP: number;
            } | undefined;
            spread?: number | undefined;
            skew?: {
                skew: number;
            } | undefined;
            openInterest?: {
                long: number;
                max: number;
                short: number;
            } | undefined;
            utilization?: {
                utilizationLong: number;
                utilizationShort: number;
            } | undefined;
            depth?: {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            } | undefined;
        }>;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
    }>;
}, {
    groups: Record<string, {
        groupIndex: number;
        pairs: Record<string, {
            pairInfo: {
                from: string;
                to: string;
                maxLeverage: number;
                groupIndex: number;
                feeIndex: number;
                maxLongOiP: number;
                maxShortOiP: number;
                spread: {
                    min: number;
                    max: number;
                };
            };
            fee?: {
                feeP: number;
            } | undefined;
            spread?: number | undefined;
            skew?: {
                skew: number;
            } | undefined;
            openInterest?: {
                long: number;
                max: number;
                short: number;
            } | undefined;
            utilization?: {
                utilizationLong: number;
                utilizationShort: number;
            } | undefined;
            depth?: {
                onePercentDepthAboveUsdc: number;
                onePercentDepthBelowUsdc: number;
            } | undefined;
        }>;
        skew?: {
            skew: number;
        } | undefined;
        openInterest?: {
            long: number;
            max: number;
            short: number;
        } | undefined;
        utilization?: {
            utilizationLong: number;
            utilizationShort: number;
        } | undefined;
    }>;
}>;
export declare const TradeSchema: z.ZodObject<{
    trader: z.ZodString;
    pairIndex: z.ZodNumber;
    index: z.ZodNumber;
    initialPosToken: z.ZodNumber;
    positionSizeUSDC: z.ZodNumber;
    openPrice: z.ZodNumber;
    buy: z.ZodBoolean;
    leverage: z.ZodNumber;
    tp: z.ZodNumber;
    sl: z.ZodNumber;
    timestamp: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    trader: string;
    pairIndex: number;
    timestamp: number;
    index: number;
    initialPosToken: number;
    positionSizeUSDC: number;
    openPrice: number;
    buy: boolean;
    leverage: number;
    tp: number;
    sl: number;
}, {
    trader: string;
    pairIndex: number;
    timestamp: number;
    index: number;
    initialPosToken: number;
    positionSizeUSDC: number;
    openPrice: number;
    buy: boolean;
    leverage: number;
    tp: number;
    sl: number;
}>;
export declare const TradeInfoSchema: z.ZodObject<{
    openInterestUSDC: z.ZodNumber;
    tpLastUpdated: z.ZodNumber;
    slLastUpdated: z.ZodNumber;
    beingMarketClosed: z.ZodBoolean;
    lossProtection: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    lossProtection: number;
    openInterestUSDC: number;
    tpLastUpdated: number;
    slLastUpdated: number;
    beingMarketClosed: boolean;
}, {
    lossProtection: number;
    openInterestUSDC: number;
    tpLastUpdated: number;
    slLastUpdated: number;
    beingMarketClosed: boolean;
}>;
export declare const OpenLimitOrderSchema: z.ZodObject<{
    trader: z.ZodString;
    pairIndex: z.ZodNumber;
    index: z.ZodNumber;
    positionSize: z.ZodNumber;
    buy: z.ZodBoolean;
    leverage: z.ZodNumber;
    tp: z.ZodNumber;
    sl: z.ZodNumber;
    price: z.ZodNumber;
    slippageP: z.ZodNumber;
    block: z.ZodNumber;
    executionFee: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    trader: string;
    pairIndex: number;
    index: number;
    buy: boolean;
    leverage: number;
    tp: number;
    sl: number;
    executionFee: number;
    slippageP: number;
    positionSize: number;
    price: number;
    block: number;
}, {
    trader: string;
    pairIndex: number;
    index: number;
    buy: boolean;
    leverage: number;
    tp: number;
    sl: number;
    executionFee: number;
    slippageP: number;
    positionSize: number;
    price: number;
    block: number;
}>;
export declare const ReferralTierSchema: z.ZodObject<{
    feeDiscountPct: z.ZodNumber;
    refRebatePct: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    feeDiscountPct: number;
    refRebatePct: number;
}, {
    feeDiscountPct: number;
    refRebatePct: number;
}>;
export declare const ReferralDiscountSchema: z.ZodObject<{
    traderDiscount: z.ZodNumber;
    referrer: z.ZodString;
    rebateShare: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    referrer: string;
    rebateShare: number;
    traderDiscount: number;
}, {
    referrer: string;
    rebateShare: number;
    traderDiscount: number;
}>;
export type Spread = z.infer<typeof SpreadSchema>;
export type PairInfo = z.infer<typeof PairInfoSchema>;
export type TradeInput = z.infer<typeof TradeInputSchema>;
export type TradeResponse = z.infer<typeof TradeResponseSchema>;
export type Price = z.infer<typeof PriceSchema>;
export type EmaPrice = z.infer<typeof EmaPriceSchema>;
export type PriceFeedResponse = z.infer<typeof PriceFeedResponseSchema>;
export type OpenInterest = z.infer<typeof OpenInterestSchema>;
export type OpenInterestLimits = z.infer<typeof OpenInterestLimitsSchema>;
export type Utilization = z.infer<typeof UtilizationSchema>;
export type Skew = z.infer<typeof SkewSchema>;
export type Fee = z.infer<typeof FeeSchema>;
export type Depth = z.infer<typeof DepthSchema>;
export type LossProtectionInfo = z.infer<typeof LossProtectionInfoSchema>;
export type PairData = z.infer<typeof PairDataSchema>;
export type Group = z.infer<typeof GroupSchema>;
export type Snapshot = z.infer<typeof SnapshotSchema>;
export type Trade = z.infer<typeof TradeSchema>;
export type TradeInfo = z.infer<typeof TradeInfoSchema>;
export type OpenLimitOrder = z.infer<typeof OpenLimitOrderSchema>;
export type ReferralTier = z.infer<typeof ReferralTierSchema>;
export type ReferralDiscount = z.infer<typeof ReferralDiscountSchema>;
export interface ContractCallOptions {
    value?: bigint;
    gasLimit?: bigint;
}
export interface TransactionReceipt {
    transactionHash: string;
    blockNumber: number;
    status: number;
    gasUsed: bigint;
}
/**
 * Convert blockchain integer to decimal (10^10 precision)
 */
export declare function fromBlockchain10(value: bigint | number | string): number;
/**
 * Convert blockchain integer to decimal (10^6 precision for USDC)
 */
export declare function fromBlockchain6(value: bigint | number | string): number;
/**
 * Convert decimal to blockchain integer (10^10 precision)
 */
export declare function toBlockchain10(value: number): bigint;
/**
 * Convert decimal to blockchain integer (10^6 precision for USDC)
 */
export declare function toBlockchain6(value: number): bigint;
/**
 * Convert blockchain integer to decimal (10^12 precision for fees)
 */
export declare function fromBlockchain12(value: bigint | number | string): number;
/**
 * Convert decimal to blockchain integer (10^12 precision for fees)
 */
export declare function toBlockchain12(value: number): bigint;
/**
 * Convert blockchain integer to decimal (10^18 precision for ETH/execution fees)
 */
export declare function fromBlockchain18(value: bigint | number | string): number;
/**
 * Convert decimal to blockchain integer (10^18 precision for ETH/execution fees)
 */
export declare function toBlockchain18(value: number): bigint;
export interface ContractPairInfo {
    feed: {
        maxOpenDeviationP: bigint;
        maxCloseDeviationP: bigint;
        feedId: string;
    };
    backupFeed: {
        maxDeviationP: bigint;
        feedId: string;
    };
    spreadP: bigint;
    pnlSpreadP: bigint;
    leverages: {
        minLeverage: bigint;
        maxLeverage: bigint;
        pnlMinLeverage: bigint;
        pnlMaxLeverage: bigint;
    };
    priceImpactMultiplier: bigint;
    skewImpactMultiplier: bigint;
    groupIndex: bigint;
    feeIndex: bigint;
    values: {
        maxGainP: bigint;
        maxSlP: bigint;
        maxLongOiP: bigint;
        maxShortOiP: bigint;
        groupOpenInterestPercentageP: bigint;
        maxWalletOIP: bigint;
        isUSDCAligned: boolean;
    };
}
export interface FeedStruct {
    maxOpenDeviationP: bigint;
    maxCloseDeviationP: bigint;
    feedId: string;
}
export interface BackupFeedStruct {
    maxDeviationP: bigint;
    feedId: string;
}
export interface LeverageStruct {
    minLeverage: bigint;
    maxLeverage: bigint;
    pnlMinLeverage: bigint;
    pnlMaxLeverage: bigint;
}
export interface ValuesStruct {
    maxGainP: bigint;
    maxSlP: bigint;
    maxLongOiP: bigint;
    maxShortOiP: bigint;
    groupOpenInterestPercentageP: bigint;
    maxWalletOIP: bigint;
    isUSDCAligned: boolean;
}
export interface PairStruct {
    feed: FeedStruct;
    backupFeed: BackupFeedStruct;
    spreadP: bigint;
    pnlSpreadP: bigint;
    leverages: LeverageStruct;
    priceImpactMultiplier: bigint;
    skewImpactMultiplier: bigint;
    groupIndex: bigint;
    feeIndex: bigint;
    values: ValuesStruct;
}
export interface GroupStruct {
    name: string;
    maxOpenInterestP: bigint;
    isSpreadDynamic: boolean;
}
export interface PnlFeesStruct {
    numTiers: bigint;
    tierP: bigint[];
    feesP: bigint[];
}
export interface FeeStruct {
    openFeeP: bigint;
    closeFeeP: bigint;
    limitOrderFeeP: bigint;
    minLevPosUSDC: bigint;
    pnlFees: PnlFeesStruct;
}
export type PairsBackendReturn = {
    pair: PairStruct;
    group: GroupStruct;
    fee: FeeStruct;
};