new BorrowSDK(config: BorrowSDKConfig)

import { BorrowSDK, ChainType } from '@satsterminal-sdk/borrow';

const sdk = new BorrowSDK({
  apiKey: 'your-api-key',
  wallet: {
    address: 'bc1q...',
    signMessage: async (msg) => wallet.signMessage(msg)
  }
});

import {
  BorrowSDK,
  ChainType,
  Units,                    // Type-safe BTC/satoshi conversions
  ResponseNormalizer,       // API response normalization
  type Satoshis,           // Branded type for satoshis
  type BTC,                // Branded type for BTC
} from '@satsterminal-sdk/borrow';

// Convert units
const btc = Units.satsToBtc(10000000);      // "0.10000000"
const sats = Units.btcToSats("0.1");        // 10000000

// Auto-detect and normalize units
const normalized = Units.normalizeToBtc(value);

// Handle various API response formats
const quotes = ResponseNormalizer.normalizeQuotes(apiResponse);

readonly userStatus: UserStatus

readonly platformWalletAddress: string | null

async setup(options?: { chain?: ChainType }): Promise<{
  platformWallet: { address: string; signature: string };
  userStatus: UserStatus;
  activeSession: ActiveSession;
  transactions: UserTransaction[];
}>

const { platformWallet, userStatus, activeSession } = await sdk.setup();
console.log('Smart Account:', platformWallet.address);

async startNewLoan(options?: { chain?: ChainType }): Promise<{
  userStatus: UserStatus;
  activeSession: ActiveSession;
}>

const { userStatus, activeSession } = await sdk.startNewLoan();
// Now ready to execute borrow

async getQuotes(params: QuoteRequest): Promise<Quote[]>

const quotes = await sdk.getQuotes({
  collateralAmount: '0.1',
  loanAmount: '5000'
});

async getWebhookConfig(): Promise<SdkWebhookConfig | null>

async updateWebhookConfig(input: SdkWebhookConfigUpdateRequest): Promise<SdkWebhookConfig>

await sdk.updateWebhookConfig({
  enabled: true,
  url: 'https://api.example.com/webhooks/satsterminal',
  events: [SdkWebhookEventType.BTC_DEPOSIT_CONFIRMED],
});

async rotateWebhookSecret(): Promise<SdkWebhookSecretResponse>

const { secret } = await sdk.rotateWebhookSecret();

async executeBorrow(quote: Quote, options?: {
  destinationAddress?: string;
}): Promise<string>

const workflowId = await sdk.executeBorrow(selectedQuote, {
  destinationAddress: '0x...'
});

await sdk.trackWorkflow(workflowId, {
  onStatusUpdate: (status) => console.log(status.label),
  onDepositReady: (info) => console.log(`Deposit ${info.amountBTC} BTC to ${info.address}`),
  onComplete: () => console.log('Borrow complete')
}, 'borrow');

async repay(
  originalBorrowId: string,
  repayAmount: string,
  options?: {
    chain?: ChainType;
    useCollateral?: boolean;
    collateralToWithdraw?: string;
    userBtcWithdrawAddress?: string;
    trackWorkflow?: boolean;
    callbacks?: WorkflowCallbacks;
  }
): Promise<string>

await sdk.repay(loanId, '1000', {
  collateralToWithdraw: '0.01',
  userBtcWithdrawAddress: 'bc1q...',
  trackWorkflow: true,
  callbacks: {
    onComplete: () => console.log('Repaid!')
  }
});

async withdrawCollateral(
  originalBorrowId: string,
  collateralAmount: string,
  btcWithdrawAddress: string,
  options?: {
    chain?: ChainType;
    trackWorkflow?: boolean;
    callbacks?: WorkflowCallbacks;
  }
): Promise<string>

await sdk.withdrawCollateral(
  loanId,
  '0.01',
  'bc1q...',
  { trackWorkflow: true, callbacks }
);

async borrowMore(
  originalBorrowId: string,
  borrowAmount: string,
  options?: {
    chain?: ChainType;
    disbursementFeeBps?: number;
    trackWorkflow?: boolean;
    callbacks?: WorkflowCallbacks;
  }
): Promise<BorrowMoreResult>

const result = await sdk.borrowMore(loanId, '500', {
  trackWorkflow: true,
  callbacks: {
    onStatusUpdate: (status) => console.log(status.label),
    onComplete: () => console.log('Additional funds disbursed!')
  }
});
console.log(result.transactionId);

async depositMore(
  originalBorrowId: string,
  collateralAmount: string,
  options?: {
    chain?: ChainType;
    trackWorkflow?: boolean;
    callbacks?: WorkflowCallbacks;
  }
): Promise<DepositMoreResult>

const result = await sdk.depositMore(loanId, '0.01', {
  trackWorkflow: true,
  callbacks: {
    onDepositReady: (info) => console.log(`Send ${info.amountBTC} BTC to ${info.address}`),
    onComplete: () => console.log('Collateral added!')
  }
});

async getLoanCollateralInfo(loanId: string): Promise<LoanCollateralInfo | null>

{
  totalCollateral: string;
  availableCollateral: string;
  maxWithdrawable: string;
  totalDebt: string;
  remainingDebt: string;
}

async getLoanHistory(options?: {
  page?: number;
  limit?: number;
  status?: 'active' | 'pending' | 'all';
}): Promise<PaginatedResponse<UserTransaction>>

const history = await sdk.getLoanHistory({
  page: 1,
  limit: 20,
  status: 'active'
});

async getPendingLoans(): Promise<UserTransaction[]>

async getRepayTransactions(loanId?: string): Promise<RepayTransaction[]>

async getRepayStatus(transactionId: string): Promise<RepayTransactionStatusResponse>

async trackWorkflow(
  workflowId: string,
  callbacks: WorkflowCallbacks,
  workflowType?: 'borrow' | 'repay'
): Promise<void>

async resumeLoan(workflowId: string, callbacks?: WorkflowCallbacks): Promise<void>

async getStatus(workflowId: string): Promise<any>

async sendBitcoin(toAddress: string, satoshis: number): Promise<string>

async getFees(params: FeesRequest): Promise<FeesResponseData>

const fees = await sdk.getFees({
  chain: ChainType.ARBITRUM,
  collateralAmount: '0.1'
});

async getQuoteFees(params: QuoteFeesRequestData): Promise<QuoteFeesResponseData>

const quotes = await sdk.getQuotes({
  collateralAmount: '0.1',
  loanAmount: '5000'
});
const best = quotes[0];

const fees = await sdk.getQuoteFees({
  collateralAmount: '0.1',
  loanAmount: '5000',
  fromChain: ChainType.BITCOIN,
  fromAssetSymbol: 'BTC',
  toChain: best.chain,
  toAssetSymbol: 'WBTC',
  loanChain: best.chain,
  loanAssetSymbol: 'USDC',
});

console.log('Bridge fee USD:', fees.bridgeFees.totalBridgeFeeUSD);
console.log('Platform fee:', fees.borrowFees.platformFee);
console.log('Net loan to user:', fees.borrowFees.netLoanAmount);
if (fees.borrowFees.feeSource === 'campaign') {
  console.log('Campaign discount applied:', fees.borrowFees.campaignSlug);
}

const [quotes, fees] = await Promise.all([
  sdk.getQuotes({ collateralAmount, loanAmount }),
  sdk.getQuoteFees({
    collateralAmount,
    loanAmount,
    fromChain: ChainType.BITCOIN,
    fromAssetSymbol: 'BTC',
    toChain: selectedChain,
    toAssetSymbol: 'WBTC',
    loanChain: selectedChain,
    loanAssetSymbol: 'USDC',
  }),
]);

async getWalletPositions(params?: {
  filterPositions?: string;
  filterTrash?: string;
}): Promise<WalletPositionsResponse>

async getWalletPortfolio(filter?: string): Promise<WalletPortfolioResponse>

async withdrawToBitcoin(params: WithdrawToBitcoinRequest): Promise<string>

async getWithdrawStatus(transactionId: string): Promise<WithdrawStatusResponse>

async withdrawToEVM(params: WithdrawToEVMRequest): Promise<string>

// Withdraw USDC to your personal wallet (gasless)
const txHash = await sdk.withdrawToEVM({
  chain: ChainType.ARBITRUM,
  amount: '100',
  destinationAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
});

console.log('Transaction hash:', txHash);
// Verify on block explorer: https://arbiscan.io/tx/{txHash}

clearSession(): void

function useBorrow(config: BorrowSDKConfig): BorrowSDK

import { useBorrow } from '@satsterminal-sdk/borrow';

const sdk = useBorrow({
  apiKey: 'your-api-key',
  wallet: walletProvider
});