@fullstackcraftllc/floe 0.0.1

package/LICENSE-COMMERCIAL

@@ -0,0 +1,74 @@
+# Commercial License Agreement
+
+**Full Stack Craft LLC - floe Commercial License**
+
+Copyright (c) 2025 Full Stack Craft LLC
+
+---
+
+## Grant of License
+
+Subject to the terms and conditions of this agreement and payment of applicable license fees, Full Stack Craft LLC ("Licensor") grants you ("Licensee") a non-exclusive, non-transferable license to use the floe software ("Software") for commercial purposes.
+
+## Permitted Uses
+
+This Commercial License permits:
+- Use in commercial, proprietary, and closed-source applications
+- Integration into SaaS platforms and trading systems
+- Deployment in production environments serving customers
+- Use in revenue-generating applications
+- No requirement to disclose source code
+
+## Restrictions
+
+Licensee may not:
+- Redistribute or resell the Software as a standalone product
+- Remove or modify license notices or attributions
+- Use the Software in a way that competes directly with Licensor's business
+- Sublicense the Software to third parties
+
+## Support and Updates
+
+Commercial License includes:
+- Email support (response within 48 business hours)
+- Access to software updates and bug fixes
+- Security patches and vulnerability fixes
+
+**Enterprise tier additionally includes:**
+- Priority support with SLA guarantees
+- Custom broker integrations
+- Dedicated support channel
+- Implementation assistance
+
+## Fees
+
+License fees are based on the tier selected:
+- **Developer**: $149/month or $1,490/year
+- **Professional**: $499/month or $4,990/year
+- **Enterprise**: Custom pricing based on requirements
+
+Contact hi@fullstackcraft.com for current pricing.
+
+## Term and Termination
+
+This license is effective upon payment and continues for the subscription period. Failure to pay renewal fees will result in termination of the license. Upon termination, Licensee must cease all use of the Software.
+
+## Warranty Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+## Limitation of Liability
+
+IN NO EVENT SHALL LICENSOR BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER ARISING OUT OF THE USE OF OR INABILITY TO USE THE SOFTWARE.
+
+## Governing Law
+
+This Agreement shall be governed by the laws of the State of Delaware, United States.
+
+---
+
+**To obtain a Commercial License:**
+- Email: hi@fullstackcraft.com
+- Website: https://fullstackcraft.com/floe/pricing
+
+Full Stack Craft LLC

package/LICENSE-MIT

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2025 Full Stack Craft LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+IMPORTANT: This MIT License only applies to individual and non-commercial use.
+For commercial use, a Commercial License is required.
+See LICENSE.md for details.

package/LICENSE.md

@@ -0,0 +1,65 @@
+# Dual License
+
+Copyright (c) 2025 Full Stack Craft LLC
+
+This software is available under two licenses. Choose the one that best fits your use case:
+
+---
+
+## 1. MIT License (For Individual/Non-Commercial Use)
+
+**This license applies to:**
+- Individual developers using floe for personal projects
+- Educational and academic purposes
+- Open-source projects (must remain open-source)
+- Non-profit organizations
+- Evaluation and testing purposes
+
+See [LICENSE-MIT](LICENSE-MIT) for full terms.
+
+**Free to use** - No payment required for individual, non-commercial use.
+
+---
+
+## 2. Commercial License (For Business/Commercial Use)
+
+**This license is required for:**
+- Any business or commercial entity using floe in production
+- SaaS applications and trading platforms
+- Proprietary software and closed-source projects
+- Fintech applications serving customers
+- Any revenue-generating use of this software
+
+**Pricing:**
+- Contact us at: **hi@fullstackcraft.com**
+- Visit: **https://fullstackcraft.com/floe/pricing**
+
+The Commercial License includes:
+- Permission to use in commercial/proprietary applications
+- No requirement to disclose source code
+- Priority support and bug fixes
+- SLA guarantees (Enterprise tier)
+- Custom broker integrations (Enterprise tier)
+
+See [LICENSE-COMMERCIAL](LICENSE-COMMERCIAL) for full terms.
+
+---
+
+## How to Choose
+
+**Use MIT License if:**
+- You're an individual developer working on personal projects
+- You're building an open-source project that will remain open-source
+- You're a student or academic using this for research/education
+
+**Use Commercial License if:**
+- You're a business using this in production
+- You're building a commercial product or service
+- You're generating revenue using this software
+- You need support, SLAs, or custom integrations
+
+---
+
+## Questions?
+
+Contact us at **hi@fullstackcraft.com** for licensing questions.

package/README.md

@@ -0,0 +1,272 @@
+# `floe`
+
+Browser-only TypeScript functions for calculating Black-Scholes, Greeks, and dealer exposures with a clean, type-safe API. Built for use in trading platforms and fintech applications.
+
+The same library that is used in Full Stack Craft's various fintech products including [The Wheel Screener](https://wheelscreener.com), [LEAPS Screener](https://leapsscreener.com), [Option Screener](https://option-screener.com),  [AMT JOY](https://amtjoy.com), and [VannaCharm](https://vannacharm.com).
+
+## 📋 Dual License
+
+**This project is dual-licensed:**
+
+- ✅ **MIT License** - Free for individuals, personal projects, and non-commercial use
+- 💼 **Commercial License** - Required for businesses and commercial applications
+
+[Read full licensing details](LICENSE.md) | [Get Commercial License](mailto:hi@fullstackcraft.com)
+
+---
+
+## Features
+
+- 🎯 **Black-Scholes Pricing** - Fast, accurate options pricing
+- 📊 **Greeks Calculations** - Delta, gamma, theta, vega, rho
+- 🔄 **Dealer Exposure Metrics** - GEX, VEX, and CEX exposures
+- 🔌 **Broker-Agnostic** - Normalize data from any broker
+- 💪 **Type-Safe** - Full TypeScript support
+- ⚡ **Zero Dependencies** - Lightweight and fast
+
+## Installation
+
+```bash
+npm install @fullstackcraftllc/floe
+```
+
+## Quick Start
+
+Nearly everything in `floe` revolves around the `NormalizedOption` interface, which provides a consistent way to represent options data regardless of the broker source:
+
+```typescript
+/**
+ * Normalized option data structure (broker-agnostic)
+ */
+export interface NormalizedOption {
+  /** Underlying symbol */
+  symbol: string;
+  /** Strike price */
+  strike: number;
+  /** Expiration date (ISO 8601) */
+  expiration: string;
+  /** Option type */
+  optionType: OptionType;
+  /** Current bid price */
+  bid: number;
+  /** Current ask price */
+  ask: number;
+  /** Last traded price */
+  last: number;
+  /** Trading volume */
+  volume: number;
+  /** Open interest */
+  openInterest: number;
+  /** Implied volatility (as decimal) */
+  impliedVolatility: number;
+  /** Pre-calculated Greeks (optional) */
+  greeks?: Greeks;
+}
+```
+
+```typescript
+import { blackScholes, calculateGreeks, calculateGEX } from '@fullstackcraftllc/floe';
+
+// Calculate option price
+const price = blackScholes({
+  spot: 100,
+  strike: 105,
+  timeToExpiry: 0.25,
+  volatility: 0.20,
+  riskFreeRate: 0.05,
+  optionType: 'call'
+});
+
+// Calculate Greeks
+const greeks = calculateGreeks({
+  spot: 100,
+  strike: 105,
+  timeToExpiry: 0.25,
+  volatility: 0.20,
+  riskFreeRate: 0.05,
+  optionType: 'call'
+});
+
+const normalizedOptions = [
+  {
+    symbol: 'AAPL',
+    strike: 105,
+    expiration: '2025-12-20',
+    optionType: 'call',
+    bid: 2.50,
+    ask: 2.60,
+    last: 2.55,
+    volume: 150,
+    openInterest: 2000,
+    impliedVolatility: 0.22
+  },
+  // ...more options
+];
+
+const gexData = calculateGEX(normalizedOptions, 100, 100);
+
+console.log('Option Price:', price);
+console.log('Delta:', greeks.delta);
+console.log('Gamma:', greeks.gamma);
+console.log('Net Gamma:', gexData.netGamma);
+console.log('Strike of Max Gamma:', gexData.maxPositiveStrike);
+console.log('Strike of Min Gamma:', gexData.maxNegativeStrike);
+console.log('Zero Gamma Level:', gexData.zeroGammaLevel);
+```
+
+## Broker Normalization
+
+Floe provides adapters for normalizing options data from multiple brokers:
+
+```typescript
+import { normalizeTastyworksData } from '@fullstackcraftllc/floe';
+
+// Tastyworks data
+const normalizedOptions = normalizeTastyworksData(rawTastyData);
+
+// Now both use the same interface
+normalizedOptions.forEach(option => {
+  const greeks = calculateGreeks(option);
+  console.log(greeks);
+});
+```
+
+## For Devs - Example / Documentation Site
+
+The website at [fullstackcraft.github.io/floe](https://fullstackcraft.github.io/floe) contains live code examples and documentation and is here locally at `./site`. It is a static site build with Next.js.
+
+## API Documentation
+
+### Black-Scholes Pricing
+
+```typescript
+blackScholes(params: BlackScholesParams): number
+```
+
+Calculate option price using Black-Scholes model.
+
+**Parameters:**
+- `spot`: Current price of underlying asset
+- `strike`: Strike price of option
+- `timeToExpiry`: Time to expiration in years
+- `volatility`: Implied volatility (annualized)
+- `riskFreeRate`: Risk-free interest rate (annualized)
+- `optionType`: 'call' | 'put'
+- `dividendYield?`: Dividend yield (optional, default 0)
+
+### Greeks Calculation
+
+```typescript
+calculateGreeks(params: BlackScholesParams): Greeks
+```
+
+Calculate all Greeks for an option.
+
+**Returns:**
+- `delta`: Rate of change of option price with respect to underlying price
+- `gamma`: Rate of change of delta with respect to underlying price
+- `theta`: Rate of change of option price with respect to time
+- `vega`: Rate of change of option price with respect to volatility
+- `rho`: Rate of change of option price with respect to interest rate
+
+### Estimate Implied Volatility Surface
+
+```typescript
+estimateIVSurface(options: NormalizedOption[], spot: number): IVSurface
+```
+
+### Dealer Exposure Metrics
+
+```typescript
+calculateGEX(options: NormalizedOption[]): GEXMetrics
+calculateVanna(options: NormalizedOption[]): VannaMetrics
+calculateCharm(options: NormalizedOption[]): CharmMetrics
+```
+
+### Notional Intraday Dealer Exposure Metrics
+
+This process assume that dealer inventory consists of the previously reported open interest at t=0 (09:30AM EST), and that all options volume is bought or sold at market price based on the NBBO at the time of the trade. This is a simplification and may not reflect actual dealer inventory changes throughout the day.
+
+Note that the nature of this calculation requires continuous intraday data including time-stamped trades and quotes to accurately model dealer inventory changes.
+
+```typescript
+calculateIntradayGEX(trades: Trade[], quotes: Quote[], initialOpenInterest: Map<string, number>, spotPrices: Map<string, number>): IntradayGEXMetrics
+```
+
+Calculate dealer exposure metrics across an options chain.
+
+## License
+
+**Free for Individuals** - Use the MIT License for personal, educational, and non-commercial projects.
+
+**Commercial License Required** - Businesses and commercial applications must obtain a commercial license.
+
+See [LICENSE.md](LICENSE.md) for full details.
+
+**Need a Commercial License?** Contact us at [hi@fullstackcraft.com](mailto:hi@fullstackcraft.com)
+
+## Pricing
+
+### Individual (MIT License)
+**$0/month** - Free forever
+- ✅ Personal projects
+- ✅ Open-source projects
+- ✅ Educational use
+- ✅ Community support
+
+### Developer (Commercial)
+**$149/month** or **$1,490/year**
+- ✅ Commercial use
+- ✅ Up to 100K calculations/month
+- ✅ Email support
+- ✅ All broker integrations
+
+### Professional (Commercial)
+**$499/month** or **$4,990/year**
+- ✅ Unlimited calculations
+- ✅ Priority support
+- ✅ SLA guarantees
+- ✅ Custom integrations
+
+### Enterprise (Commercial)
+**Custom pricing**
+- ✅ White-label options
+- ✅ Dedicated support
+- ✅ On-premise deployment
+- ✅ Custom broker adapters
+
+[Contact hi@fullstackcraft.com for Enterprise pricing](mailto:hi@fullstackcraft.com)
+
+## Documentation
+
+Full documentation coming soon at [fullstackcraft.github.io/floe](https://fullstackcraft.github.io/floe)
+
+## Support
+
+- **Email:** hi@fullstackcraft.com
+- **Bug Reports:** [GitHub Issues](https://github.com/FullStackCraft/floe/issues)
+- **Discussions:** [GitHub Discussions](https://github.com/FullStackCraft/floe/discussions)
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR.
+
+By contributing, you agree that your contributions will be licensed under the same dual-license terms.
+
+## Roadmap
+
+- [ ] Homepage / documentation site
+- [ ] Volatility surface estimation with a variety of interpolation methods
+- [ ] Implied PDF calculations
+- [ ] Tradier integration, normalization, and docs
+- [ ] TradeStation integration, normalization, and docs
+- [ ] Interactive Brokers integration, normalization, and docs
+
+
+## Credits
+
+Built with ❤️ by [Full Stack Craft LLC](https://fullstackcraft.com)
+
+---
+
+**© 2025 Full Stack Craft LLC** - All rights reserved.

package/dist/adapters/index.d.ts

@@ -0,0 +1,52 @@
+import { RawOptionData, OptionChain, BrokerAdapter } from '../types';
+/**
+ * Generic adapter that maps common field names
+ * This is a fallback adapter when broker-specific adapters are not available
+ */
+export declare const genericAdapter: BrokerAdapter;
+/**
+ * Schwab-specific adapter for Schwab API responses
+ */
+export declare const schwabAdapter: BrokerAdapter;
+/**
+ * Interactive Brokers adapter
+ */
+export declare const ibkrAdapter: BrokerAdapter;
+/**
+ * TD Ameritrade / Schwab TDA API adapter
+ */
+export declare const tdaAdapter: BrokerAdapter;
+/**
+ * Map of broker names to their adapters
+ */
+export declare const brokerAdapters: Record<string, BrokerAdapter>;
+/**
+ * Get adapter for a specific broker
+ * @param brokerName - Name of the broker
+ * @returns Broker adapter function
+ */
+export declare function getAdapter(brokerName: string): BrokerAdapter;
+/**
+ * Create an option chain from raw broker data
+ *
+ * @param symbol - Underlying symbol (e.g., 'SPY')
+ * @param spot - Current spot price of the underlying
+ * @param riskFreeRate - Risk-free interest rate (as decimal, e.g., 0.05 for 5%)
+ * @param dividendYield - Dividend yield (as decimal, e.g., 0.02 for 2%)
+ * @param rawOptions - Array of raw option data from broker
+ * @param broker - Broker name for adapter selection (default: 'generic')
+ * @returns Complete option chain with market context
+ *
+ * @example
+ * ```typescript
+ * const chain = createOptionChain(
+ *   'SPY',
+ *   450.50,
+ *   0.05,
+ *   0.02,
+ *   rawOptionsFromBroker,
+ *   'schwab'
+ * );
+ * ```
+ */
+export declare function createOptionChain(symbol: string, spot: number, riskFreeRate: number, dividendYield: number, rawOptions: RawOptionData[], broker?: string): OptionChain;

package/dist/adapters/index.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brokerAdapters = exports.tdaAdapter = exports.ibkrAdapter = exports.schwabAdapter = exports.genericAdapter = void 0;
+exports.getAdapter = getAdapter;
+exports.createOptionChain = createOptionChain;
+/**
+ * Generic adapter that maps common field names
+ * This is a fallback adapter when broker-specific adapters are not available
+ */
+const genericAdapter = (data) => {
+    return {
+        strike: Number(data.strike || data.strikePrice || 0),
+        expiration: data.expiration || data.expirationDate || '',
+        expirationTimestamp: data.expirationTimestamp || new Date(data.expiration || data.expirationDate).getTime(),
+        optionType: (data.optionType || data.putCall || '').toLowerCase() === 'call' ? 'call' : 'put',
+        bid: Number(data.bid || 0),
+        ask: Number(data.ask || 0),
+        mark: Number(data.mark || (data.bid + data.ask) / 2 || 0),
+        last: Number(data.last || data.lastPrice || 0),
+        volume: Number(data.volume || 0),
+        openInterest: Number(data.openInterest || 0),
+        impliedVolatility: Number(data.impliedVolatility || data.iv || 0),
+    };
+};
+exports.genericAdapter = genericAdapter;
+/**
+ * Schwab-specific adapter for Schwab API responses
+ */
+const schwabAdapter = (data) => {
+    return {
+        strike: Number(data.strikePrice || 0),
+        expiration: data.expirationDate || '',
+        expirationTimestamp: new Date(data.expirationDate).getTime(),
+        optionType: (data.putCall || '').toLowerCase() === 'call' ? 'call' : 'put',
+        bid: Number(data.bid || 0),
+        ask: Number(data.ask || 0),
+        mark: Number(data.mark || 0),
+        last: Number(data.last || 0),
+        volume: Number(data.totalVolume || 0),
+        openInterest: Number(data.openInterest || 0),
+        impliedVolatility: Number(data.volatility || 0),
+    };
+};
+exports.schwabAdapter = schwabAdapter;
+/**
+ * Interactive Brokers adapter
+ */
+const ibkrAdapter = (data) => {
+    return {
+        strike: Number(data.strike || 0),
+        expiration: data.lastTradeDateOrContractMonth || '',
+        expirationTimestamp: new Date(data.lastTradeDateOrContractMonth).getTime(),
+        optionType: (data.right || '').toLowerCase() === 'c' ? 'call' : 'put',
+        bid: Number(data.bid || 0),
+        ask: Number(data.ask || 0),
+        mark: Number(data.mark || (data.bid + data.ask) / 2 || 0),
+        last: Number(data.lastTradedPrice || 0),
+        volume: Number(data.volume || 0),
+        openInterest: Number(data.openInterest || 0),
+        impliedVolatility: Number(data.impliedVolatility || 0),
+    };
+};
+exports.ibkrAdapter = ibkrAdapter;
+/**
+ * TD Ameritrade / Schwab TDA API adapter
+ */
+const tdaAdapter = (data) => {
+    return {
+        strike: Number(data.strikePrice || 0),
+        expiration: data.expirationDate || '',
+        expirationTimestamp: data.expirationDate ? new Date(data.expirationDate).getTime() : 0,
+        optionType: (data.putCall || '').toLowerCase() === 'call' ? 'call' : 'put',
+        bid: Number(data.bid || 0),
+        ask: Number(data.ask || 0),
+        mark: Number(data.mark || 0),
+        last: Number(data.last || 0),
+        volume: Number(data.totalVolume || 0),
+        openInterest: Number(data.openInterest || 0),
+        impliedVolatility: Number(data.volatility || 0),
+    };
+};
+exports.tdaAdapter = tdaAdapter;
+/**
+ * Map of broker names to their adapters
+ */
+exports.brokerAdapters = {
+    generic: exports.genericAdapter,
+    schwab: exports.schwabAdapter,
+    ibkr: exports.ibkrAdapter,
+    tda: exports.tdaAdapter,
+};
+/**
+ * Get adapter for a specific broker
+ * @param brokerName - Name of the broker
+ * @returns Broker adapter function
+ */
+function getAdapter(brokerName) {
+    return exports.brokerAdapters[brokerName.toLowerCase()] || exports.genericAdapter;
+}
+/**
+ * Create an option chain from raw broker data
+ *
+ * @param symbol - Underlying symbol (e.g., 'SPY')
+ * @param spot - Current spot price of the underlying
+ * @param riskFreeRate - Risk-free interest rate (as decimal, e.g., 0.05 for 5%)
+ * @param dividendYield - Dividend yield (as decimal, e.g., 0.02 for 2%)
+ * @param rawOptions - Array of raw option data from broker
+ * @param broker - Broker name for adapter selection (default: 'generic')
+ * @returns Complete option chain with market context
+ *
+ * @example
+ * ```typescript
+ * const chain = createOptionChain(
+ *   'SPY',
+ *   450.50,
+ *   0.05,
+ *   0.02,
+ *   rawOptionsFromBroker,
+ *   'schwab'
+ * );
+ * ```
+ */
+function createOptionChain(symbol, spot, riskFreeRate, dividendYield, rawOptions, broker = 'generic') {
+    const adapter = getAdapter(broker);
+    return {
+        symbol,
+        spot,
+        riskFreeRate,
+        dividendYield,
+        options: rawOptions.map(adapter),
+    };
+}

package/dist/blackscholes/index.d.ts

@@ -0,0 +1,73 @@
+import { BlackScholesParams, Greeks, OptionType } from '../types';
+/**
+ * Calculate option price using Black-Scholes model
+ *
+ * @param params - Black-Scholes parameters
+ * @returns Option price
+ *
+ * @example
+ * ```typescript
+ * const price = blackScholes({
+ *   spot: 100,
+ *   strike: 105,
+ *   timeToExpiry: 0.25,
+ *   volatility: 0.20,
+ *   riskFreeRate: 0.05,
+ *   optionType: 'call'
+ * });
+ * ```
+ */
+export declare function blackScholes(params: BlackScholesParams): number;
+/**
+ * Calculate complete option Greeks using Black-Scholes-Merton model
+ * Includes all first, second, and third-order Greeks
+ *
+ * @param params - Black-Scholes parameters
+ * @returns Complete Greeks including price
+ *
+ * @example
+ * ```typescript
+ * const greeks = calculateGreeks({
+ *   spot: 100,
+ *   strike: 105,
+ *   timeToExpiry: 0.25,
+ *   volatility: 0.20,
+ *   riskFreeRate: 0.05,
+ *   optionType: 'call'
+ * });
+ * ```
+ */
+export declare function calculateGreeks(params: BlackScholesParams): Greeks;
+/**
+ * Calculate implied volatility using bisection method
+ *
+ * @param price - Observed option price
+ * @param spot - Current spot price
+ * @param strike - Strike price
+ * @param riskFreeRate - Risk-free interest rate (as decimal)
+ * @param dividendYield - Dividend yield (as decimal)
+ * @param timeToExpiry - Time to expiration in years
+ * @param optionType - 'call' or 'put'
+ * @returns Implied volatility as a percentage (e.g., 20.0 for 20%)
+ *
+ * @example
+ * ```typescript
+ * const iv = calculateImpliedVolatility(5.50, 100, 105, 0.05, 0, 0.25, 'call');
+ * console.log(`IV: ${iv}%`);
+ * ```
+ */
+export declare function calculateImpliedVolatility(price: number, spot: number, strike: number, riskFreeRate: number, dividendYield: number, timeToExpiry: number, optionType: OptionType): number;
+/**
+ * Get milliseconds until expiration
+ *
+ * @param expirationTimestamp - Expiration timestamp in milliseconds
+ * @returns Milliseconds until expiration
+ */
+export declare function getMillisecondsToExpiration(expirationTimestamp: number): number;
+/**
+ * Get time to expiration in years
+ *
+ * @param expirationTimestamp - Expiration timestamp in milliseconds
+ * @returns Time to expiration in years
+ */
+export declare function getTimeToExpirationInYears(expirationTimestamp: number): number;