public_api.json

{
  "release": "4.1.0",
  "rule": "One name, one contract: a name two packages export is the same object in both, or it is listed under shared_names with the reason the two are deliberately different.",
  "packages": {
    "alphalab": {
      "__version__": "value builtins.str"
    },
    "alphalab.allocation": {
      "AccountAllocation": "class alphalab.allocation.capital.AccountAllocation(account: 'CapitalAccount', requested: 'Decimal', allocated: 'Decimal', unallocated: 'Decimal', scale: 'Decimal | None', base_free: 'Decimal') -> None",
      "AllocationCompleted": "class alphalab.allocation.events.AllocationCompleted(event_id: str, timestamp: float, num_orders_generated: int, total_notional: decimal.Decimal) -> None",
      "AllocationConstraints": "class alphalab.allocation.constraints.AllocationConstraints(max_weight_per_asset: decimal.Decimal = Decimal('1.0'), min_weight_per_asset: decimal.Decimal = Decimal('-1.0'), allow_shorting: bool = True, enforce_integer_quantities: bool = False) -> None",
      "AllocationEngine": "class alphalab.allocation.engine.AllocationEngine()",
      "AllocationError": "class alphalab.allocation.exceptions.AllocationError",
      "AllocationEvent": "class alphalab.allocation.events.AllocationEvent(event_id: str, timestamp: float) -> None",
      "AllocationOptimizer": "class alphalab.allocation.optimizer.AllocationOptimizer(*args, **kwargs)",
      "AllocationRejected": "class alphalab.allocation.events.AllocationRejected(event_id: str, timestamp: float, reason: str) -> None",
      "AllocationRule": "alias AllocationRule",
      "AllocationStarted": "class alphalab.allocation.events.AllocationStarted(event_id: str, timestamp: float, num_intents: int) -> None",
      "AllocationState": "class alphalab.allocation.state.AllocationState(budget: alphalab.allocation.budget.CapitalBudget, history: alphalab.common.append_log.AppendOnlyLog[alphalab.core.order_request.OrderRequest] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.allocation.events.AllocationEvent] = <factory>, notional_allocated: decimal.Decimal = Decimal('0.00'), reservations: alphalab.common.persistent_map.PersistentMap[str, decimal.Decimal] = <factory>, contributions: alphalab.common.persistent_map.PersistentMap[str, tuple[alphalab.core.contribution.StrategyContribution, ...]] = <factory>, strategy_positions: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentMap[str, decimal.Decimal]] | None = <factory>, strategy_capital: alphalab.common.persistent_map.PersistentMap[str, alphalab.allocation.ceilings.StrategyCapital] = <factory>) -> None",
      "AllocationValidationError": "class alphalab.allocation.exceptions.AllocationValidationError",
      "BudgetExceeded": "class alphalab.allocation.events.BudgetExceeded(event_id: str, timestamp: float, reason: str, requested_notional: decimal.Decimal, available_budget: decimal.Decimal) -> None",
      "BudgetExceededError": "class alphalab.allocation.exceptions.BudgetExceededError",
      "CAPITAL_ALLOCATION_SCHEME": "value builtins.str",
      "CAPITAL_PLAN_SCHEME": "value builtins.str",
      "CapitalAccount": "class alphalab.allocation.capital.CapitalAccount(account_id: 'str', broker_id: 'str', currency: 'str', available: 'Decimal', reserved: 'Decimal') -> None",
      "CapitalAllocationPlan": "class alphalab.allocation.capital.CapitalAllocationPlan(name: 'str', base_currency: 'str', as_of: 'float', accounts: 'tuple[CapitalAccount, ...]', placements: 'tuple[CapitalPlacement, ...]', rule: 'AllocationRule', limits: 'tuple[CapitalLimit, ...]', oversubscription: 'OversubscriptionRule', granularity: 'Decimal') -> None",
      "CapitalAllocationResult": "class alphalab.allocation.capital.CapitalAllocationResult(plan_id: 'str', status: 'CapitalAllocationStatus', base_currency: 'str', total_free: 'Decimal', placements: 'tuple[PlacementAllocation, ...] | None', accounts: 'tuple[AccountAllocation, ...]', dimensions: 'tuple[DimensionAllocation, ...]', checks: 'tuple[LimitCheck, ...]', reasons: 'tuple[str, ...]', conversions: 'tuple[CapitalConversion, ...]') -> None",
      "CapitalAllocationStatus": "enum alphalab.allocation.capital.CapitalAllocationStatus[ALLOCATED, REFUSED]",
      "CapitalBudget": "class alphalab.allocation.budget.CapitalBudget(global_capital: decimal.Decimal, maximum_exposure: decimal.Decimal, cash_buffer: decimal.Decimal = Decimal('0.00'), strategy_budgets: collections.abc.Mapping[str, decimal.Decimal] = <factory>, currency: str = '', enforce_strategy_budgets: bool = False) -> None",
      "CapitalConversion": "class alphalab.allocation.capital.CapitalConversion(amount: 'Decimal', base: 'str', quote: 'str', rate: 'Decimal', rate_as_of: 'float', source: 'str', derived: 'bool', converted: 'Decimal') -> None",
      "CapitalDimension": "enum alphalab.allocation.capital.CapitalDimension[STRATEGY, MARKET, BROKER, ACCOUNT, CURRENCY]",
      "CapitalLimit": "class alphalab.allocation.capital.CapitalLimit(dimension: 'CapitalDimension', bucket: 'str', maximum_share: 'Decimal | None', minimum_share: 'Decimal | None') -> None",
      "CapitalPlacement": "class alphalab.allocation.capital.CapitalPlacement(strategy_id: 'str', market: 'str', account_id: 'str') -> None",
      "ConversionRecord": "class alphalab.common.currency.ConversionRecord(*args, **kwargs)",
      "CurrencyConverter": "class alphalab.common.currency.CurrencyConverter(*args, **kwargs)",
      "DimensionAllocation": "class alphalab.allocation.capital.DimensionAllocation(dimension: 'CapitalDimension', amounts: 'Mapping[str, Decimal]', shares: 'Mapping[str, Decimal]', native: 'Mapping[str, Decimal] | None') -> None",
      "EqualWeightSizing": "class alphalab.allocation.sizing.EqualWeightSizing(num_assets: int) -> None",
      "EqualWeights": "class alphalab.allocation.capital.EqualWeights(fraction: 'Decimal') -> None",
      "FixedAmounts": "class alphalab.allocation.capital.FixedAmounts(amounts: 'Mapping[CapitalPlacement, Decimal]') -> None",
      "FixedDollarSizing": "class alphalab.allocation.sizing.FixedDollarSizing()",
      "FixedQuantitySizing": "class alphalab.allocation.sizing.FixedQuantitySizing()",
      "IntentAllocator": "class alphalab.allocation.allocator.IntentAllocator()",
      "LimitCheck": "class alphalab.allocation.capital.LimitCheck(limit: 'CapitalLimit', share: 'Decimal', satisfied: 'bool') -> None",
      "NettingCompleted": "class alphalab.allocation.events.NettingCompleted(event_id: str, timestamp: float, asset_id: str, net_quantity: decimal.Decimal, side: str) -> None",
      "NettingEngine": "class alphalab.allocation.netting.NettingEngine()",
      "OrderRequest": "class alphalab.core.order_request.OrderRequest(order_id: str, strategy_id: str, asset_id: str, side: alphalab.core.enums.Side, quantity: decimal.Decimal, price: decimal.Decimal, timestamp: float = 0.0, contributions: tuple[alphalab.core.contribution.StrategyContribution, ...] = <factory>, terms: alphalab.common.order_terms.OrderTerms = OrderTerms(order_type=<OrderType.MARKET: 'market'>, limit_price=None, stop_price=None, time_in_force=<TimeInForce.DAY: 'day'>, expire_at=None)) -> None",
      "OversubscriptionRule": "enum alphalab.allocation.capital.OversubscriptionRule[REFUSE, PRO_RATA]",
      "PlacementAllocation": "class alphalab.allocation.capital.PlacementAllocation(placement: 'CapitalPlacement', currency: 'str', requested: 'Decimal', allocated: 'Decimal', base_amount: 'Decimal', conversion: 'CapitalConversion | None') -> None",
      "PlacementWeights": "class alphalab.allocation.capital.PlacementWeights(weights: 'Mapping[CapitalPlacement, Decimal]', source: 'str') -> None",
      "RateRecord": "class alphalab.common.currency.RateRecord(*args, **kwargs)",
      "SizingModel": "class alphalab.allocation.sizing.SizingModel(*args, **kwargs)",
      "SizingRefusedError": "class alphalab.allocation.exceptions.SizingRefusedError",
      "StrategyContribution": "class alphalab.core.contribution.StrategyContribution(strategy_id: str, quantity: decimal.Decimal) -> None",
      "TargetWeightSizing": "class alphalab.allocation.sizing.TargetWeightSizing()",
      "UnknownReservationError": "class alphalab.allocation.exceptions.UnknownReservationError",
      "VolatilityTargetSizing": "class alphalab.allocation.sizing.VolatilityTargetSizing(target_vol: decimal.Decimal, asset_vols: collections.abc.Mapping[str, decimal.Decimal]) -> None",
      "allocate_capital": "function alphalab.allocation.capital.allocate_capital(plan: 'CapitalAllocationPlan', converter: 'CurrencyConverter') -> 'CapitalAllocationResult'",
      "allocation_history": "function alphalab.allocation.views.allocation_history(state: alphalab.allocation.state.AllocationState) -> collections.abc.Sequence[alphalab.core.order_request.OrderRequest]",
      "capital_budget": "function alphalab.allocation.capital.capital_budget(result: 'CapitalAllocationResult', *, account_id: 'str', maximum_exposure: 'Decimal', cash_buffer: 'Decimal', enforce_strategy_budgets: 'bool' = False) -> 'CapitalBudget'",
      "contributions_from": "function alphalab.core.contribution.contributions_from(sized: collections.abc.Iterable[tuple[str, decimal.Decimal]]) -> tuple[alphalab.core.contribution.StrategyContribution, ...]",
      "current_budget": "function alphalab.allocation.views.current_budget(state: alphalab.allocation.state.AllocationState) -> alphalab.allocation.budget.CapitalBudget",
      "open_reservations": "function alphalab.allocation.views.open_reservations(state: alphalab.allocation.state.AllocationState) -> collections.abc.Mapping[str, decimal.Decimal]",
      "recent_orders_for_asset": "function alphalab.allocation.views.recent_orders_for_asset(state: alphalab.allocation.state.AllocationState, asset_id: str) -> collections.abc.Sequence[alphalab.core.order_request.OrderRequest]",
      "reserved_capital": "function alphalab.allocation.capital.reserved_capital(state: 'AllocationState', *, currency: 'str') -> 'Decimal'",
      "reserved_for_order": "function alphalab.allocation.views.reserved_for_order(state: alphalab.allocation.state.AllocationState, order_id: str) -> decimal.Decimal",
      "total_notional_allocated": "function alphalab.allocation.views.total_notional_allocated(state: alphalab.allocation.state.AllocationState) -> decimal.Decimal",
      "validate_long_only": "function alphalab.allocation.validation.validate_long_only(asset_id: str, delta: decimal.Decimal, committed: decimal.Decimal) -> None",
      "validate_net_quantity": "function alphalab.allocation.validation.validate_net_quantity(quantity: decimal.Decimal, enforce_long_only: bool = False) -> None"
    },
    "alphalab.allocation.snapshot": {
      "ALLOCATION_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "ALLOCATION_SNAPSHOT_SCHEMA": "value builtins.int",
      "AllocationEventRecord": "class alphalab.allocation.snapshot.AllocationEventRecord(event_type: 'str', event: 'AllocationEvent') -> None",
      "AllocationSnapshot": "class alphalab.allocation.snapshot.AllocationSnapshot(budget: 'CapitalBudget', history: 'tuple[OrderRequest, ...]', events: 'tuple[AllocationEventRecord, ...]', notional_allocated: 'Decimal', reservations: 'Mapping[str, Decimal]', contributions: 'Mapping[str, tuple[StrategyContribution, ...]]', strategy_positions: 'Mapping[str, Mapping[str, Decimal]] | None' = None, strategy_capital: 'Mapping[str, StrategyCapital]' = <factory>, schema_version: 'int' = 3) -> None",
      "capture": "function alphalab.allocation.snapshot.capture(state: 'AllocationState') -> 'AllocationSnapshot'",
      "from_primitives": "function alphalab.allocation.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'AllocationSnapshot'",
      "restore": "function alphalab.allocation.snapshot.restore(snapshot: 'AllocationSnapshot') -> 'AllocationState'"
    },
    "alphalab.alt_data": {
      "AdjustedFundamental": "class alphalab.alt_data.fundamentals.AdjustedFundamental(observation: 'FundamentalObservation', as_of: 'float', value: 'Decimal', unit: 'str', factor: 'Decimal', applied: 'tuple[ShareCountChange, ...]') -> None",
      "AggregateStep": "class alphalab.alt_data.fundamentals.AggregateStep(known_at: 'float', value: 'Decimal | None', unit: 'str | None', observed_at: 'float | None', record_ids: 'tuple[str, ...]', reason: 'str') -> None",
      "AggregatedSentiment": "class alphalab.alt_data.sentiment.AggregatedSentiment(asset_id: str, window_start: float, window_end: float, release_date: float, mean_sentiment: decimal.Decimal, volume: int, source: alphalab.alt_data.provenance.DataProvenance) -> None",
      "Aggregation": "enum alphalab.alt_data.fundamentals.Aggregation[LATEST, LATEST_ANNUAL, TRAILING_TWELVE_MONTHS]",
      "AltDataError": "class alphalab.alt_data.exceptions.AltDataError",
      "AltDataFeatureValue": "class alphalab.alt_data.feature_bridge.AltDataFeatureValue(feature_id: str, version: int, asset_id: str | None, value: float, timestamp: float) -> None",
      "AltDataInputError": "class alphalab.alt_data.exceptions.AltDataInputError",
      "BOOK_EQUITY": "value builtins.str",
      "CASH": "value builtins.str",
      "CURRENT_ASSETS": "value builtins.str",
      "CURRENT_LIABILITIES": "value builtins.str",
      "ConvertedFundamental": "class alphalab.alt_data.fundamentals.ConvertedFundamental(observation: 'FundamentalObservation', as_of: 'float', value: 'Decimal', unit: 'str', rate: 'Decimal | None', rate_pair: 'tuple[str, str] | None', rate_as_of: 'float | None', rate_source: 'str | None') -> None",
      "CreditCardSpendingObservation": "class alphalab.alt_data.credit_card.CreditCardSpendingObservation(asset_id: str, reference_period: float, release_date: float, spending_growth_yoy: decimal.Decimal, source: alphalab.alt_data.provenance.DataProvenance, transaction_count_growth_yoy: decimal.Decimal | None = None) -> None",
      "DIVIDENDS_PER_SHARE": "value builtins.str",
      "DataProvenance": "class alphalab.alt_data.provenance.DataProvenance(vendor: str, coverage_description: str, confidence: decimal.Decimal) -> None",
      "DeliverySchedule": "class alphalab.alt_data.streaming.DeliverySchedule(set_version: 'str', visibility: 'VisibilityRule', deliveries: 'tuple[ObservationDelivery[T], ...]', unverified: 'int') -> None",
      "EARNINGS": "value builtins.str",
      "EARNINGS_PER_SHARE": "value builtins.str",
      "EBITDA": "value builtins.str",
      "ESGScore": "class alphalab.alt_data.esg.ESGScore(asset_id: str, reference_period: float, release_date: float, environmental_score: decimal.Decimal, social_score: decimal.Decimal, governance_score: decimal.Decimal, source: alphalab.alt_data.provenance.DataProvenance) -> None",
      "ExternalObservation": "class alphalab.alt_data.observation.ExternalObservation(category: 'str', subject: 'str', metric: 'str', value: 'Decimal', unit: 'str', stamp: 'PointInTimeStamp', source: 'ObservationSource', period: 'ReferencePeriod | None', revision: 'int') -> None",
      "FREE_CASH_FLOW": "value builtins.str",
      "FUNDAMENTAL_KEY_SCHEME": "value builtins.str",
      "FinancialRatios": "class alphalab.alt_data.fundamentals.FinancialRatios(subject: 'str', as_of: 'float', gross_margin: 'Decimal | None', operating_margin: 'Decimal | None', net_margin: 'Decimal | None', return_on_equity: 'Decimal | None', return_on_assets: 'Decimal | None', debt_to_equity: 'Decimal | None', current_ratio: 'Decimal | None', undefined: 'Mapping[str, str]', record_ids: 'tuple[str, ...]') -> None",
      "FinancialStatement": "class alphalab.alt_data.fundamentals.FinancialStatement(subject: 'str', statement: 'StatementType', fiscal_period: 'FiscalPeriod', as_of: 'float', policy: 'VintagePolicy', items: 'Mapping[str, FundamentalObservation]') -> None",
      "FiscalPeriod": "class alphalab.alt_data.fundamentals.FiscalPeriod(fiscal_year: 'int', fiscal_quarter: 'int | None', start: 'float', end: 'float') -> None",
      "FundamentalInput": "class alphalab.alt_data.fundamentals.FundamentalInput(name: 'str', statement: 'StatementType', line_item: 'str', aggregation: 'Aggregation') -> None",
      "FundamentalInputs": "class alphalab.alt_data.fundamentals.FundamentalInputs(subject: 'str', as_of: 'float', visibility: 'VisibilityRule', policy: 'VintagePolicy', values: 'Mapping[str, Decimal]', units: 'Mapping[str, str]', record_ids: 'Mapping[str, tuple[str, ...]]', observed_at: 'Mapping[str, float]', missing: 'Mapping[str, str]') -> None",
      "FundamentalObservation": "class alphalab.alt_data.fundamentals.FundamentalObservation(subject: 'str', statement: 'StatementType', line_item: 'str', fiscal_period: 'FiscalPeriod', value: 'Decimal', unit: 'str', published_at: 'float', stamp: 'PointInTimeStamp', source: 'ObservationSource', revision: 'int') -> None",
      "GROSS_PROFIT": "value builtins.str",
      "GrowthValue": "class alphalab.alt_data.fundamentals.GrowthValue(subject: 'str', line_item: 'str', as_of: 'float', current: 'FundamentalObservation | None', prior: 'FundamentalObservation | None', growth: 'Decimal | None', reason: 'str') -> None",
      "INFORMATION_EVENT_KEY_SCHEME": "value builtins.str",
      "InformationEvent": "class alphalab.alt_data.information.InformationEvent(event_type: 'str', subject: 'str', stamp: 'PointInTimeStamp', source: 'ObservationSource', measurements: 'Mapping[str, Decimal]', attributes: 'Mapping[str, str]', revision: 'int') -> None",
      "NewsSentiment": "class alphalab.alt_data.news.NewsSentiment(asset_id: str, headline: str, published_at: float, release_date: float, sentiment_score: decimal.Decimal, source: alphalab.alt_data.provenance.DataProvenance) -> None",
      "OBSERVATION_KEY_SCHEME": "value builtins.str",
      "OBSERVATION_SET_KEY_SCHEME": "value builtins.str",
      "OPERATING_INCOME": "value builtins.str",
      "ObservationDelivery": "class alphalab.alt_data.streaming.ObservationDelivery(known_at: 'float', delivery_id: 'str', record: 'T') -> None",
      "ObservationSet": "class alphalab.alt_data.observation_set.ObservationSet(name: 'str', kind: 'str', source: 'ObservationSource', records: 'tuple[T, ...]', parent_version: 'str | None', transformations: 'tuple[SetTransformation, ...]', version: 'str') -> None",
      "ObservationSource": "class alphalab.alt_data.source.ObservationSource(source_id: 'str', version: 'str | None', content_hash: 'str | None', retrieved_at: 'float | None', quality: 'DataProvenance | None' = None) -> None",
      "ObservationStream": "class alphalab.alt_data.streaming.ObservationStream(name: 'str', source: 'ObservationSource', kind: 'str | None' = None, records: 'AppendOnlyLog[T]' = <factory>, _ids: 'PersistentMap[str, None]' = <factory>, _vintages: 'PersistentMap[tuple[str, ...], PersistentMap[int, float | None]]' = <factory>) -> None",
      "ObservationView": "class alphalab.alt_data.observation_set.ObservationView(set_version: 'str', visibility: 'VisibilityRule', index: 'PointInTimeIndex[T]', series: 'Mapping[tuple[str, ...], PointInTimeIndex[T]]', figures: 'Mapping[tuple[str, ...], tuple[T, ...]]') -> None",
      "PointInTimeError": "class alphalab.alt_data.exceptions.PointInTimeError",
      "PointInTimeSelection": "class alphalab.alt_data.observation_set.PointInTimeSelection(set_version: 'str', as_of: 'float', visibility: 'VisibilityRule', records: 'tuple[T, ...]', pending: 'int', unverified: 'int') -> None",
      "QuotedRate": "class alphalab.alt_data.fundamentals.QuotedRate(*args, **kwargs)",
      "REVENUE": "value builtins.str",
      "RateTable": "class alphalab.alt_data.fundamentals.RateTable(*args, **kwargs)",
      "ReferencePeriod": "class alphalab.alt_data.observation.ReferencePeriod(start: 'float', end: 'float', label: 'str') -> None",
      "Restatement": "class alphalab.alt_data.fundamentals.Restatement(original: 'FundamentalObservation', latest: 'FundamentalObservation', change: 'Decimal', revisions: 'int') -> None",
      "SHARES_OUTSTANDING": "value builtins.str",
      "SatelliteMetricType": "enum alphalab.alt_data.satellite.SatelliteMetricType[PARKING_LOT_TRAFFIC, STORAGE_TANK_FILL_LEVEL, CROP_HEALTH_INDEX, CONSTRUCTION_ACTIVITY]",
      "SatelliteObservation": "class alphalab.alt_data.satellite.SatelliteObservation(asset_id: str, metric_type: alphalab.alt_data.satellite.SatelliteMetricType, capture_date: float, release_date: float, value: decimal.Decimal, source: alphalab.alt_data.provenance.DataProvenance) -> None",
      "SessionCalendar": "class alphalab.alt_data.sessions.SessionCalendar(*args, **kwargs)",
      "SessionPlacement": "class alphalab.alt_data.sessions.SessionPlacement(calendar_id: 'str', instant: 'float', timing: 'SessionTiming', tradable_at: 'float') -> None",
      "SessionTiming": "enum alphalab.alt_data.sessions.SessionTiming[IN_SESSION, BEFORE_OPEN, BETWEEN_SESSIONS, AFTER_CLOSE, NON_TRADING_DAY]",
      "SetRecord": "class alphalab.alt_data.observation_set.SetRecord(*args, **kwargs)",
      "SetTransformation": "class alphalab.alt_data.observation_set.SetTransformation(operation: 'str', detail: 'str', records_before: 'int', records_after: 'int') -> None",
      "ShareCountChange": "class alphalab.alt_data.fundamentals.ShareCountChange(subject: 'str', effective_at: 'float', ratio: 'Decimal', source: 'str', known_at: 'float | None' = None) -> None",
      "ShippingMetricType": "enum alphalab.alt_data.shipping.ShippingMetricType[PORT_CONGESTION_INDEX, VESSEL_COUNT, CARGO_VOLUME]",
      "ShippingObservation": "class alphalab.alt_data.shipping.ShippingObservation(identifier: str, metric_type: alphalab.alt_data.shipping.ShippingMetricType, reference_period: float, release_date: float, value: decimal.Decimal, source: alphalab.alt_data.provenance.DataProvenance) -> None",
      "StatementType": "enum alphalab.alt_data.fundamentals.StatementType[INCOME_STATEMENT, BALANCE_SHEET, CASH_FLOW_STATEMENT]",
      "TOTAL_ASSETS": "value builtins.str",
      "TOTAL_DEBT": "value builtins.str",
      "TrailingValue": "class alphalab.alt_data.fundamentals.TrailingValue(subject: 'str', line_item: 'str', as_of: 'float', value: 'Decimal | None', unit: 'str | None', periods: 'tuple[str, ...]', record_ids: 'tuple[str, ...]', reason: 'str') -> None",
      "ValuationMetrics": "class alphalab.alt_data.fundamentals.ValuationMetrics(subject: 'str', as_of: 'float', currency: 'str', price: 'Decimal', price_observed_at: 'float', market_capitalization: 'Decimal | None', enterprise_value: 'Decimal | None', earnings_yield: 'Decimal | None', price_to_earnings: 'Decimal | None', book_to_market: 'Decimal | None', price_to_book: 'Decimal | None', sales_to_price: 'Decimal | None', enterprise_value_to_ebitda: 'Decimal | None', enterprise_value_to_sales: 'Decimal | None', free_cash_flow_yield: 'Decimal | None', dividend_yield: 'Decimal | None', undefined: 'Mapping[str, str]', record_ids: 'tuple[str, ...]') -> None",
      "VintagePolicy": "enum alphalab.alt_data.observation_set.VintagePolicy[AS_KNOWN, ORIGINAL]",
      "adjusted_for_share_changes": "function alphalab.alt_data.fundamentals.adjusted_for_share_changes(observation: 'FundamentalObservation', changes: 'Iterable[ShareCountChange]', as_of: 'float') -> 'AdjustedFundamental'",
      "aggregate_from_news": "function alphalab.alt_data.sentiment.aggregate_from_news(news_items: tuple[alphalab.alt_data.news.NewsSentiment, ...], asset_id: str, window_start: float, window_end: float, source: alphalab.alt_data.provenance.DataProvenance) -> alphalab.alt_data.sentiment.AggregatedSentiment",
      "aggregate_timeline": "function alphalab.alt_data.fundamentals.aggregate_timeline(view: 'ObservationView[FundamentalObservation]', subject: 'str', spec: 'FundamentalInput', policy: 'VintagePolicy') -> 'tuple[AggregateStep, ...]'",
      "build_observation_set": "function alphalab.alt_data.observation_set.build_observation_set(name: 'str', records: 'Iterable[T]', source: 'ObservationSource') -> 'ObservationSet[T]'",
      "canonical_event_key": "function alphalab.alt_data.information.canonical_event_key(event: 'InformationEvent') -> 'str'",
      "canonical_fundamental_key": "function alphalab.alt_data.fundamentals.canonical_fundamental_key(observation: 'FundamentalObservation') -> 'str'",
      "canonical_observation_key": "function alphalab.alt_data.observation.canonical_observation_key(observation: 'ExternalObservation') -> 'str'",
      "canonical_set_key": "function alphalab.alt_data.observation_set.canonical_set_key(name: 'str', kind: 'str', source: 'ObservationSource', parent_version: 'str | None', transformations: 'Iterable[SetTransformation]', record_ids: 'Iterable[str]') -> 'str'",
      "composite_score": "function alphalab.alt_data.esg.composite_score(esg: alphalab.alt_data.esg.ESGScore, weights: tuple[decimal.Decimal, decimal.Decimal, decimal.Decimal] = (Decimal('0.3333333333333333333333333333'), Decimal('0.3333333333333333333333333333'), Decimal('0.3333333333333333333333333333'))) -> decimal.Decimal",
      "converted_fundamental": "function alphalab.alt_data.fundamentals.converted_fundamental(observation: 'FundamentalObservation', currency: 'str', rates: 'RateTable', as_of: 'float') -> 'ConvertedFundamental'",
      "currency_of_per_share_unit": "function alphalab.alt_data.fundamentals.currency_of_per_share_unit(unit: 'str') -> 'str'",
      "delivery_schedule": "function alphalab.alt_data.streaming.delivery_schedule(obs_set: 'ObservationSet[T]', visibility: 'VisibilityRule') -> 'DeliverySchedule[T]'",
      "derive_set_version": "function alphalab.alt_data.observation_set.derive_set_version(name: 'str', kind: 'str', source: 'ObservationSource', parent_version: 'str | None', transformations: 'Iterable[SetTransformation]', record_ids: 'Iterable[str]') -> 'str'",
      "financial_ratios": "function alphalab.alt_data.fundamentals.financial_ratios(inputs: 'FundamentalInputs') -> 'FinancialRatios'",
      "from_aggregated_sentiment": "function alphalab.alt_data.feature_bridge.from_aggregated_sentiment(obs: alphalab.alt_data.sentiment.AggregatedSentiment, feature_id: str, version: int) -> alphalab.alt_data.feature_bridge.AltDataFeatureValue",
      "from_credit_card_observation": "function alphalab.alt_data.feature_bridge.from_credit_card_observation(obs: alphalab.alt_data.credit_card.CreditCardSpendingObservation, feature_id: str, version: int) -> alphalab.alt_data.feature_bridge.AltDataFeatureValue",
      "from_esg_score": "function alphalab.alt_data.feature_bridge.from_esg_score(obs: alphalab.alt_data.esg.ESGScore, feature_id: str, version: int, weights: tuple[decimal.Decimal, decimal.Decimal, decimal.Decimal] | None = None) -> alphalab.alt_data.feature_bridge.AltDataFeatureValue",
      "from_news_sentiment": "function alphalab.alt_data.feature_bridge.from_news_sentiment(obs: alphalab.alt_data.news.NewsSentiment, feature_id: str, version: int) -> alphalab.alt_data.feature_bridge.AltDataFeatureValue",
      "from_satellite_observation": "function alphalab.alt_data.feature_bridge.from_satellite_observation(obs: alphalab.alt_data.satellite.SatelliteObservation, feature_id: str, version: int) -> alphalab.alt_data.feature_bridge.AltDataFeatureValue",
      "from_shipping_observation": "function alphalab.alt_data.feature_bridge.from_shipping_observation(obs: alphalab.alt_data.shipping.ShippingObservation, feature_id: str, version: int) -> alphalab.alt_data.feature_bridge.AltDataFeatureValue",
      "fundamental_as_of": "function alphalab.alt_data.fundamentals.fundamental_as_of(view: 'ObservationView[FundamentalObservation]', subject: 'str', statement: 'StatementType', line_item: 'str', fiscal_period_label: 'str', as_of: 'float', policy: 'VintagePolicy') -> 'FundamentalObservation | None'",
      "fundamental_inputs_as_of": "function alphalab.alt_data.fundamentals.fundamental_inputs_as_of(view: 'ObservationView[FundamentalObservation]', subject: 'str', as_of: 'float', policy: 'VintagePolicy', inputs: 'Sequence[FundamentalInput]') -> 'FundamentalInputs'",
      "known_by": "function alphalab.alt_data.observation_set.known_by(obs_set: 'ObservationSet[T]', as_of: 'float', visibility: 'VisibilityRule') -> 'ObservationSet[T]'",
      "latest_fundamental": "function alphalab.alt_data.fundamentals.latest_fundamental(view: 'ObservationView[FundamentalObservation]', subject: 'str', statement: 'StatementType', line_item: 'str', as_of: 'float', policy: 'VintagePolicy', *, annual: 'bool | None') -> 'FundamentalObservation | None'",
      "latest_vintages": "function alphalab.alt_data.observation_set.latest_vintages(records: 'Iterable[T]') -> 'tuple[T, ...]'",
      "observation_from_release": "function alphalab.alt_data.observation.observation_from_release(record: 'PointInTimeRecord', *, category: 'str', subject: 'str', metric: 'str', value: 'Decimal', unit: 'str', source: 'ObservationSource', revision: 'int') -> 'ExternalObservation'",
      "original_vintages": "function alphalab.alt_data.observation_set.original_vintages(records: 'Iterable[T]') -> 'tuple[T, ...]'",
      "originals_only": "function alphalab.alt_data.observation_set.originals_only(obs_set: 'ObservationSet[T]') -> 'ObservationSet[T]'",
      "place_in_session": "function alphalab.alt_data.sessions.place_in_session(instant: 'float', calendar: 'SessionCalendar') -> 'SessionPlacement'",
      "place_record": "function alphalab.alt_data.sessions.place_record(record: 'StampedRecord', visibility: 'VisibilityRule', calendar: 'SessionCalendar') -> 'SessionPlacement'",
      "restatements": "function alphalab.alt_data.fundamentals.restatements(obs_set: 'ObservationSet[FundamentalObservation]') -> 'tuple[Restatement, ...]'",
      "restrict_measured": "function alphalab.alt_data.information.restrict_measured(event_set: 'ObservationSet[InformationEvent]', measurement: 'str') -> 'ObservationSet[InformationEvent]'",
      "restrict_observed": "function alphalab.alt_data.observation_set.restrict_observed(obs_set: 'ObservationSet[T]', start: 'float', end: 'float') -> 'ObservationSet[T]'",
      "restrict_subjects": "function alphalab.alt_data.observation_set.restrict_subjects(obs_set: 'ObservationSet[T]', subjects: 'Iterable[str]') -> 'ObservationSet[T]'",
      "statement_as_of": "function alphalab.alt_data.fundamentals.statement_as_of(view: 'ObservationView[FundamentalObservation]', subject: 'str', statement: 'StatementType', fiscal_period_label: 'str', as_of: 'float', policy: 'VintagePolicy') -> 'FinancialStatement | None'",
      "surprise": "function alphalab.alt_data.information.surprise(event: 'InformationEvent', actual: 'str', expected: 'str') -> 'Decimal'",
      "trailing_twelve_months": "function alphalab.alt_data.fundamentals.trailing_twelve_months(view: 'ObservationView[FundamentalObservation]', subject: 'str', statement: 'StatementType', line_item: 'str', as_of: 'float', policy: 'VintagePolicy') -> 'TrailingValue'",
      "valuation_metrics": "function alphalab.alt_data.fundamentals.valuation_metrics(inputs: 'FundamentalInputs', price: 'Decimal', price_unit: 'str', price_observed_at: 'float') -> 'ValuationMetrics'",
      "verify_observation_set": "function alphalab.alt_data.observation_set.verify_observation_set(obs_set: 'ObservationSet[T]') -> 'bool'",
      "year_over_year_growth": "function alphalab.alt_data.fundamentals.year_over_year_growth(view: 'ObservationView[FundamentalObservation]', subject: 'str', statement: 'StatementType', line_item: 'str', as_of: 'float', policy: 'VintagePolicy', *, annual: 'bool') -> 'GrowthValue'"
    },
    "alphalab.analytics": {
      "AnalyticsEngine": "class alphalab.analytics.engine.AnalyticsEngine()",
      "AnalyticsError": "class alphalab.analytics.exceptions.AnalyticsError",
      "AnalyticsEvent": "class alphalab.analytics.events.AnalyticsEvent(event_id: str, timestamp: float) -> None",
      "AnalyticsState": "class alphalab.analytics.state.AnalyticsState(reports: tuple[alphalab.analytics.report.PerformanceReport, ...] = <factory>, events: tuple[alphalab.analytics.events.AnalyticsEvent, ...] = <factory>) -> None",
      "AnalyticsValidationError": "class alphalab.analytics.exceptions.AnalyticsValidationError",
      "AttributionDimension": "enum alphalab.analytics.attribution.AttributionDimension[STRATEGY, ASSET, SECTOR, COUNTRY, CURRENCY, VENUE, BROKER, FACTOR, EXECUTION]",
      "AttributionMetrics": "class alphalab.analytics.attribution.AttributionMetrics(pnl_by_strategy: collections.abc.Mapping[str, decimal.Decimal], pnl_by_asset: collections.abc.Mapping[str, decimal.Decimal], pnl_by_sector: collections.abc.Mapping[str, decimal.Decimal]) -> None",
      "AttributionReport": "class alphalab.analytics.attribution.AttributionReport(dimensions: collections.abc.Mapping[alphalab.analytics.attribution.AttributionDimension, alphalab.analytics.attribution.DimensionAttribution], realized_pnl: decimal.Decimal, currencies: tuple[str, ...]) -> None",
      "Availability": "enum alphalab.analytics.attribution.Availability[AVAILABLE, PARTIAL, NO_METADATA]",
      "BenchmarkBasis": "class alphalab.analytics.benchmark.BenchmarkBasis(periods_per_year: 'float', risk_free_rate: 'float') -> None",
      "BenchmarkStatistics": "class alphalab.analytics.benchmark.BenchmarkStatistics(basis: 'BenchmarkBasis', observations: 'int', portfolio_only_instants: 'int', benchmark_only_instants: 'int', active_return: 'float | None', tracking_error: 'float | None', information_ratio: 'float | None', beta: 'float | None', alpha: 'float | None', correlation: 'float | None', r_squared: 'float | None', up_capture: 'float | None', down_capture: 'float | None', relative_return: 'float') -> None",
      "BucketRisk": "class alphalab.analytics.risk_budget.BucketRisk(bucket: 'str', net_exposure: 'Decimal', gross_exposure: 'Decimal', capital_share: 'float', contribution: 'float', share: 'float', lines: 'int', native_exposure: 'Decimal | None') -> None",
      "BudgetBasis": "enum alphalab.analytics.risk_budget.BudgetBasis[ABSOLUTE, RELATIVE]",
      "BudgetCheck": "class alphalab.analytics.risk_budget.BudgetCheck(limit: 'BudgetLimit', present: 'bool', used: 'float', remaining: 'float | None', above_minimum: 'float | None', deviation: 'float | None', status: 'BudgetStatus') -> None",
      "BudgetLimit": "class alphalab.analytics.risk_budget.BudgetLimit(dimension: 'RiskDimension', bucket: 'str', basis: 'BudgetBasis', maximum: 'float | None', minimum: 'float | None', target: 'float | None') -> None",
      "BudgetStatus": "enum alphalab.analytics.risk_budget.BudgetStatus[WITHIN, AT_LIMIT, BREACHED, BELOW_MINIMUM]",
      "CLASSIFICATION_SCHEME": "value builtins.str",
      "COVARIANCE_SCHEME": "value builtins.str",
      "CapitalConcentration": "class alphalab.analytics.cross_strategy.CapitalConcentration(dimension: 'str', currency: 'str', amounts: 'Mapping[str, Decimal]', total: 'Decimal', shares: 'Mapping[str, float]', herfindahl: 'float', effective_count: 'float', largest: 'str', largest_share: 'float') -> None",
      "Classification": "class alphalab.analytics.risk_model.Classification(dimension: 'str', labels: 'Mapping[str, str]', source: 'str', as_of: 'float | None') -> None",
      "CommonDimension": "enum alphalab.analytics.cross_strategy.CommonDimension[INSTRUMENT, CURRENCY, CLASSIFICATION]",
      "CommonExposure": "class alphalab.analytics.cross_strategy.CommonExposure(bucket: 'str', by_strategy: 'Mapping[str, Decimal]', net_exposure: 'Decimal', gross_exposure: 'Decimal', shared: 'bool', opposing: 'bool') -> None",
      "CommonExposureReport": "class alphalab.analytics.cross_strategy.CommonExposureReport(dimension: 'CommonDimension', label: 'str', source: 'str', buckets: 'tuple[CommonExposure, ...]') -> None",
      "ConcentrationMetrics": "class alphalab.analytics.decomposition.ConcentrationMetrics(herfindahl: 'float', effective_positions: 'float', largest_weight: 'float', largest_asset_id: 'str') -> None",
      "CorrelationMatrix": "class alphalab.analytics.risk_model.CorrelationMatrix(assets: 'tuple[str, ...]', values: 'tuple[tuple[float, ...], ...]', currency: 'str', period: 'str', observations: 'int | None', covariance_id: 'str') -> None",
      "CovarianceMatrix": "class alphalab.analytics.risk_model.CovarianceMatrix(assets: 'tuple[str, ...]', values: 'tuple[tuple[float, ...], ...]', currency: 'str', period: 'str', source: 'str', observations: 'int | None', parent_id: 'str | None' = None, derivation: 'str | None' = None, factors: 'FactorStructure | None' = None) -> None",
      "Definiteness": "class alphalab.analytics.risk_model.Definiteness(kind: 'DefinitenessKind', rank: 'int', smallest_pivot: 'float', largest_pivot: 'float', pivot_floor: 'float', zero_variance_assets: 'tuple[str, ...]') -> None",
      "DefinitenessKind": "enum alphalab.analytics.risk_model.DefinitenessKind[POSITIVE_DEFINITE, SINGULAR, INDEFINITE]",
      "DimensionAttribution": "class alphalab.analytics.attribution.DimensionAttribution(dimension: alphalab.analytics.attribution.AttributionDimension, buckets: collections.abc.Mapping[str, decimal.Decimal], availability: alphalab.analytics.attribution.Availability, covered: int, total: int, uncovered: tuple[str, ...], reconciles: bool) -> None",
      "DimensionRisk": "class alphalab.analytics.risk_budget.DimensionRisk(dimension: 'RiskDimension', buckets: 'tuple[BucketRisk, ...]', total_contribution: 'float', residual: 'float', source: 'str', classification_id: 'str | None') -> None",
      "DrawdownMetrics": "class alphalab.analytics.drawdown.DrawdownMetrics(drawdowns: tuple[float, ...], max_drawdown: float, ulcer_index: float) -> None",
      "EXCHANGE_RATE_FACTOR_PREFIX": "value builtins.str",
      "ExposureLine": "class alphalab.analytics.risk_budget.ExposureLine(*args, **kwargs)",
      "ExposureMetrics": "class alphalab.analytics.exposure.ExposureMetrics(gross: decimal.Decimal, net: decimal.Decimal, long: decimal.Decimal, short: decimal.Decimal, cash_pct: float, leverage: float) -> None",
      "ExposureSimilarity": "class alphalab.analytics.cross_strategy.ExposureSimilarity(first: 'str', second: 'str', shared_instruments: 'tuple[str, ...]', jaccard: 'float', same_direction_overlap: 'Decimal', opposing_overlap: 'Decimal', first_overlap_share: 'float', second_overlap_share: 'float', cosine_similarity: 'float | None', exposure_correlation: 'float | None') -> None",
      "FACTOR_LOADINGS_SCHEME": "value builtins.str",
      "FACTOR_STRUCTURE_SCHEME": "value builtins.str",
      "FactorCrowding": "class alphalab.analytics.cross_strategy.FactorCrowding(factor: 'str', by_strategy: 'Mapping[str, float]', aggregate_exposure: 'float', gross_exposure: 'float', alignment: 'float | None', concentration: 'float | None', aligned_strategies: 'tuple[str, ...]') -> None",
      "FactorCrowdingReport": "class alphalab.analytics.cross_strategy.FactorCrowdingReport(loadings_id: 'str', capital: 'Decimal', factors: 'tuple[FactorCrowding, ...]', pairs: 'tuple[FactorExposureOverlap, ...]') -> None",
      "FactorExposureOverlap": "class alphalab.analytics.cross_strategy.FactorExposureOverlap(first: 'str', second: 'str', cosine_similarity: 'float | None') -> None",
      "FactorLoadings": "class alphalab.analytics.risk_model.FactorLoadings(factors: 'tuple[str, ...]', assets: 'tuple[str, ...]', values: 'tuple[tuple[float, ...], ...]', source: 'str', lineage: 'Mapping[str, str]', as_of: 'float | None') -> None",
      "FactorRisk": "class alphalab.analytics.risk_model.FactorRisk(covariance_id: 'str', currency: 'str', period: 'str', volatility: 'float', exposures: 'Mapping[str, float]', factors: 'Mapping[str, float]', specific: 'Mapping[str, float]', factor_total: 'float', specific_total: 'float', residual: 'float') -> None",
      "FactorStructure": "class alphalab.analytics.risk_model.FactorStructure(loadings: 'FactorLoadings', factor_covariance: 'CovarianceMatrix', specific: 'tuple[float, ...]') -> None",
      "LeverageMetrics": "class alphalab.analytics.decomposition.LeverageMetrics(gross_exposure: 'Decimal', net_exposure: 'Decimal', gross_leverage: 'Decimal', net_leverage: 'Decimal', long_exposure: 'Decimal', short_exposure: 'Decimal') -> None",
      "LineRisk": "class alphalab.analytics.risk_budget.LineRisk(strategy_id: 'str', asset_id: 'str', currency: 'str', native_value: 'Decimal', value: 'Decimal', weight: 'float', contribution: 'float') -> None",
      "LiquidityRisk": "class alphalab.analytics.decomposition.LiquidityRisk(days_to_liquidate: 'Mapping[str, float]', worst_asset_id: 'str', worst_days: 'float', participation_limit: 'Decimal') -> None",
      "PerformanceReport": "class alphalab.analytics.report.PerformanceReport(report_id: str, timestamp: float, returns: alphalab.analytics.report.ReturnSummary, risk: alphalab.analytics.report.RiskSummary, drawdowns: alphalab.analytics.drawdown.DrawdownMetrics, exposure: alphalab.analytics.exposure.ExposureMetrics, trades: alphalab.analytics.summary.TradeMetrics, attribution: alphalab.analytics.attribution.AttributionMetrics, ending_capital: decimal.Decimal) -> None",
      "Periodicity": "enum alphalab.analytics.report.Periodicity[DECLARED, OBSERVED, UNDEFINED, ASSUMED]",
      "PortfolioSnapshot": "class alphalab.analytics.engine.PortfolioSnapshot(timestamp: float, total_equity: decimal.Decimal, cash: decimal.Decimal, long_exposure: decimal.Decimal, short_exposure: decimal.Decimal) -> None",
      "PositionRisk": "class alphalab.analytics.decomposition.PositionRisk(asset_id: 'str', market_value: 'Decimal', currency: 'str', returns: 'tuple[float, ...]') -> None",
      "RISK_BUDGET_REPORT_SCHEME": "value builtins.str",
      "RISK_BUDGET_SCHEME": "value builtins.str",
      "ReportGenerated": "class alphalab.analytics.events.ReportGenerated(event_id: str, timestamp: float, report_id: str, num_snapshots: int, num_trades: int) -> None",
      "ReturnSummary": "class alphalab.analytics.report.ReturnSummary(total_return: float | None, cagr: float | None, arithmetic_return: float | None, geometric_return: float | None, period_returns: tuple[float, ...], periods_per_year: float | None = None, periodicity: alphalab.analytics.report.Periodicity = <Periodicity.UNDEFINED: 'UNDEFINED'>, years_elapsed: float | None = None) -> None",
      "RiskBudget": "class alphalab.analytics.risk_budget.RiskBudget(name: 'str', limits: 'tuple[BudgetLimit, ...]', tolerance: 'float') -> None",
      "RiskBudgetReport": "class alphalab.analytics.risk_budget.RiskBudgetReport(budget_id: 'str', reporting_currency: 'str', period: 'str', capital: 'Decimal', covariance_id: 'str', volatility: 'float', risk: 'RiskContributions', lines: 'tuple[LineRisk, ...]', dimensions: 'tuple[DimensionRisk, ...]', checks: 'tuple[BudgetCheck, ...]') -> None",
      "RiskContributions": "class alphalab.analytics.risk_model.RiskContributions(weights: 'Mapping[str, float]', variance: 'float', volatility: 'float', marginal: 'Mapping[str, float]', total: 'Mapping[str, float]', relative: 'Mapping[str, float]', covariance_id: 'str') -> None",
      "RiskDecomposition": "class alphalab.analytics.decomposition.RiskDecomposition(policy: 'VaRPolicy', volatility: 'float', value_at_risk: 'float', conditional_value_at_risk: 'float', tail_ratio: 'float', beta: 'float | None', max_drawdown: 'float', concentration: 'ConcentrationMetrics', leverage: 'LeverageMetrics', risk_contributions: 'Mapping[str, float]', factor_exposure: 'Mapping[str, float]', liquidity: 'LiquidityRisk | None') -> None",
      "RiskDimension": "enum alphalab.analytics.risk_budget.RiskDimension[ASSET, STRATEGY, SECTOR, COUNTRY, CURRENCY]",
      "RiskSummary": "class alphalab.analytics.report.RiskSummary(sharpe_ratio: float | None, sortino_ratio: float | None, calmar_ratio: float | None, value_at_risk_95: float | None, cvar_95: float | None, annualized_volatility: float | None, risk_free_rate: float | None = None) -> None",
      "SharedCapitalPool": "class alphalab.analytics.cross_strategy.SharedCapitalPool(pool: 'str', by_strategy: 'Mapping[str, Decimal]', total: 'Decimal', shared: 'bool') -> None",
      "StrategyCorrelation": "class alphalab.analytics.cross_strategy.StrategyCorrelation(covariance: 'CovarianceMatrix', correlation: 'CorrelationMatrix') -> None",
      "StrategyReturns": "class alphalab.analytics.cross_strategy.StrategyReturns(strategy_id: 'str', returns: 'tuple[float, ...]', currency: 'str', period: 'str') -> None",
      "TradeFacts": "class alphalab.analytics.attribution.TradeFacts(trade_id: str, currency: str | None = None, venue: str | None = None, broker: str | None = None, country: str | None = None, factor_pnl: collections.abc.Mapping[str, decimal.Decimal] | None = None, execution_costs: collections.abc.Mapping[str, decimal.Decimal] | None = None) -> None",
      "TradeMetrics": "class alphalab.analytics.summary.TradeMetrics(win_rate: float | None, loss_rate: float | None, avg_win: decimal.Decimal | None, avg_loss: decimal.Decimal | None, profit_factor: float | None, expectancy: decimal.Decimal | None, avg_holding_period: float | None, turnover: float | None, fills: int | None = None, closed_trades: int | None = None) -> None",
      "TradeRecord": "class alphalab.analytics.attribution.TradeRecord(trade_id: str, asset_id: str, sector_id: str | None, realized_pnl: decimal.Decimal, notional_value: decimal.Decimal, holding_period_seconds: float | None, contributions: tuple[alphalab.core.contribution.StrategyContribution, ...] = <factory>) -> None",
      "VaRMethod": "enum alphalab.analytics.decomposition.VaRMethod[HISTORICAL, GAUSSIAN, CORNISH_FISHER]",
      "VaRPolicy": "class alphalab.analytics.decomposition.VaRPolicy(method: 'VaRMethod', confidence: 'float') -> None",
      "all_reports": "function alphalab.analytics.views.all_reports(state: alphalab.analytics.state.AnalyticsState) -> tuple[alphalab.analytics.report.PerformanceReport, ...]",
      "annualized_volatility": "function alphalab.analytics.returns.annualized_volatility(returns: tuple[float, ...], periods: float) -> float | None",
      "arithmetic_return": "function alphalab.analytics.returns.arithmetic_return(returns: tuple[float, ...]) -> float | None",
      "attribute": "function alphalab.analytics.attribution.attribute(trades: collections.abc.Sequence[alphalab.analytics.attribution.TradeRecord], facts: collections.abc.Mapping[str, alphalab.analytics.attribution.TradeFacts] | None = None, dimensions: collections.abc.Sequence[alphalab.analytics.attribution.AttributionDimension] | None = None) -> alphalab.analytics.attribution.AttributionReport",
      "benchmark_statistics": "function alphalab.analytics.benchmark.benchmark_statistics(portfolio: 'Mapping[float, Decimal | float]', benchmark: 'Mapping[float, Decimal | float]', basis: 'BenchmarkBasis') -> 'BenchmarkStatistics'",
      "cagr": "function alphalab.analytics.returns.cagr(start_value: decimal.Decimal, end_value: decimal.Decimal, years: float) -> float | None",
      "calculate_attribution": "function alphalab.analytics.attribution.calculate_attribution(trades: collections.abc.Sequence[alphalab.analytics.attribution.TradeRecord]) -> alphalab.analytics.attribution.AttributionMetrics",
      "calculate_drawdowns": "function alphalab.analytics.drawdown.calculate_drawdowns(equity_curve: tuple[float, ...]) -> alphalab.analytics.drawdown.DrawdownMetrics",
      "calculate_exposure": "function alphalab.analytics.exposure.calculate_exposure(long_val: decimal.Decimal, short_val: decimal.Decimal, cash: decimal.Decimal) -> alphalab.analytics.exposure.ExposureMetrics",
      "calculate_trade_metrics": "function alphalab.analytics.summary.calculate_trade_metrics(profits: tuple[decimal.Decimal, ...], holding_periods: tuple[float | None, ...], total_traded_notional: decimal.Decimal, average_equity: decimal.Decimal) -> alphalab.analytics.summary.TradeMetrics",
      "calmar_ratio": "function alphalab.analytics.metrics.calmar_ratio(cagr_value: float | None, max_drawdown: float) -> float | None",
      "capital_concentration": "function alphalab.analytics.cross_strategy.capital_concentration(amounts: 'Mapping[str, Decimal]', *, currency: 'str', dimension: 'str') -> 'CapitalConcentration'",
      "capital_overlap": "function alphalab.analytics.cross_strategy.capital_overlap(allocations: 'Mapping[str, Mapping[str, Decimal]]', *, currency: 'str') -> 'tuple[SharedCapitalPool, ...]'",
      "common_exposures": "function alphalab.analytics.cross_strategy.common_exposures(lines: 'Iterable[ExposureLine]', *, by: 'CommonDimension', classification: 'Classification | None') -> 'CommonExposureReport'",
      "concentration": "function alphalab.analytics.decomposition.concentration(positions: 'Sequence[PositionRisk]') -> 'ConcentrationMetrics'",
      "conditional_var": "function alphalab.analytics.metrics.conditional_var(returns: tuple[float, ...], confidence: float = 0.95) -> float | None",
      "correlation_matrix": "function alphalab.analytics.decomposition.correlation_matrix(positions: 'Sequence[PositionRisk]') -> 'Mapping[str, Mapping[str, float]]'",
      "covariance_matrix": "function alphalab.analytics.decomposition.covariance_matrix(positions: 'Sequence[PositionRisk]') -> 'Mapping[str, Mapping[str, float]]'",
      "currency_loadings": "function alphalab.analytics.risk_model.currency_loadings(denominations: 'Mapping[str, str]', reporting_currency: 'str', *, as_of: 'float | None') -> 'FactorLoadings'",
      "decompose": "function alphalab.analytics.decomposition.decompose(positions: 'Sequence[PositionRisk]', portfolio_returns: 'Sequence[float]', equity: 'Decimal', equity_curve: 'Sequence[float]', policy: 'VaRPolicy', benchmark: 'Sequence[float] | None' = None, loadings: 'Mapping[str, Mapping[str, float]] | None' = None, units: 'Mapping[str, Decimal] | None' = None, average_daily_volume: 'Mapping[str, Decimal] | None' = None, participation_limit: 'Decimal | None' = None) -> 'RiskDecomposition'",
      "euler_decomposition": "function alphalab.analytics.risk_model.euler_decomposition(weights: 'Mapping[str, float]', covariance: 'CovarianceMatrix | FactorStructure') -> 'RiskContributions'",
      "evaluate_risk_budget": "function alphalab.analytics.risk_budget.evaluate_risk_budget(lines: 'Iterable[ExposureLine]', *, capital: 'Decimal', reporting_currency: 'str', covariance: 'CovarianceMatrix', budget: 'RiskBudget', classifications: 'Sequence[Classification]') -> 'RiskBudgetReport'",
      "factor_cholesky_pivots": "function alphalab.analytics.risk_model.factor_cholesky_pivots(loadings: 'Sequence[Sequence[float]]', factor_covariance: 'Sequence[Sequence[float]]', specific: 'Sequence[float]') -> 'tuple[float, ...] | None'",
      "factor_crowding": "function alphalab.analytics.cross_strategy.factor_crowding(lines: 'Iterable[ExposureLine]', loadings: 'FactorLoadings', *, capital: 'Decimal') -> 'FactorCrowdingReport'",
      "factor_exposure": "function alphalab.analytics.decomposition.factor_exposure(positions: 'Sequence[PositionRisk]', loadings: 'Mapping[str, Mapping[str, float]]') -> 'Mapping[str, float]'",
      "factor_risk": "function alphalab.analytics.risk_model.factor_risk(weights: 'Mapping[str, float]', covariance: 'CovarianceMatrix | FactorStructure') -> 'FactorRisk'",
      "geometric_return": "function alphalab.analytics.returns.geometric_return(returns: tuple[float, ...]) -> float | None",
      "gross_weights": "function alphalab.analytics.decomposition.gross_weights(positions: 'Sequence[PositionRisk]') -> 'Mapping[str, float]'",
      "herfindahl_index": "function alphalab.analytics.risk_model.herfindahl_index(shares: 'Iterable[float]') -> 'float'",
      "latest_performance_summary": "function alphalab.analytics.views.latest_performance_summary(state: alphalab.analytics.state.AnalyticsState) -> alphalab.analytics.report.PerformanceReport | None",
      "leverage": "function alphalab.analytics.decomposition.leverage(positions: 'Sequence[PositionRisk]', equity: 'Decimal') -> 'LeverageMetrics'",
      "liquidity_risk": "function alphalab.analytics.decomposition.liquidity_risk(positions: 'Sequence[PositionRisk]', units: 'Mapping[str, Decimal]', average_daily_volume: 'Mapping[str, Decimal]', participation_limit: 'Decimal') -> 'LiquidityRisk'",
      "percentile_loss": "function alphalab.analytics.decomposition.percentile_loss(returns: 'Sequence[float]', fraction: 'float') -> 'float'",
      "portfolio_beta": "function alphalab.analytics.decomposition.portfolio_beta(portfolio_returns: 'Sequence[float]', benchmark: 'Sequence[float]') -> 'float'",
      "portfolio_factor_exposures": "function alphalab.analytics.risk_model.portfolio_factor_exposures(weights: 'Mapping[str, float]', loadings: 'FactorLoadings') -> 'Mapping[str, float]'",
      "portfolio_volatility": "function alphalab.analytics.decomposition.portfolio_volatility(positions: 'Sequence[PositionRisk]') -> 'float'",
      "risk_contributions": "function alphalab.analytics.decomposition.risk_contributions(positions: 'Sequence[PositionRisk]') -> 'Mapping[str, float]'",
      "rolling_return": "function alphalab.analytics.rolling.rolling_return(returns: tuple[float, ...], window: int) -> tuple[float, ...]",
      "rolling_sharpe": "function alphalab.analytics.rolling.rolling_sharpe(returns: tuple[float, ...], window: int, risk_free_rate: float, periods: float) -> tuple[float | None, ...]",
      "rolling_volatility": "function alphalab.analytics.rolling.rolling_volatility(returns: tuple[float, ...], window: int, periods: float) -> tuple[float, ...]",
      "sharpe_ratio": "function alphalab.analytics.metrics.sharpe_ratio(returns: tuple[float, ...], risk_free_rate: float, periods: float) -> float | None",
      "sortino_ratio": "function alphalab.analytics.metrics.sortino_ratio(returns: tuple[float, ...], risk_free_rate: float, periods: float) -> float | None",
      "split_realized_pnl": "function alphalab.analytics.attribution.split_realized_pnl(realized_pnl: decimal.Decimal, contributions: collections.abc.Sequence[alphalab.core.contribution.StrategyContribution]) -> tuple[tuple[str, decimal.Decimal], ...]",
      "strategy_overlap": "function alphalab.analytics.cross_strategy.strategy_overlap(lines: 'Iterable[ExposureLine]') -> 'tuple[ExposureSimilarity, ...]'",
      "strategy_return_correlation": "function alphalab.analytics.cross_strategy.strategy_return_correlation(returns: 'Sequence[StrategyReturns]', *, source: 'str') -> 'StrategyCorrelation'",
      "tail_ratio": "function alphalab.analytics.decomposition.tail_ratio(policy: 'VaRPolicy', returns: 'Sequence[float]') -> 'float'",
      "total_reports_generated": "function alphalab.analytics.views.total_reports_generated(state: alphalab.analytics.state.AnalyticsState) -> int",
      "total_return": "function alphalab.analytics.returns.total_return(start_value: decimal.Decimal, end_value: decimal.Decimal) -> float | None",
      "validate_capital": "function alphalab.analytics.validation.validate_capital(capital: decimal.Decimal) -> None",
      "validate_returns": "function alphalab.analytics.validation.validate_returns(returns: tuple[float, ...]) -> None",
      "value_at_risk": "function alphalab.analytics.metrics.value_at_risk(returns: tuple[float, ...], confidence: float = 0.95) -> float | None"
    },
    "alphalab.api": {
      "AnalyticsEngine": "class alphalab.analytics.engine.AnalyticsEngine()",
      "AvailabilityAfterLag": "class alphalab.api.AvailabilityAfterLag(lag_seconds: 'float') -> None",
      "AvailabilityAtNextOpen": "class alphalab.api.AvailabilityAtNextOpen(column: 'str', calendar: 'SessionCalendar') -> None",
      "AvailabilityFromColumn": "class alphalab.api.AvailabilityFromColumn(column: 'str') -> None",
      "AvailabilityNotDeclared": "class alphalab.api.AvailabilityNotDeclared() -> None",
      "AvailabilityRule": "alias AvailabilityRule",
      "DataRequest": "class alphalab.api.DataRequest(symbols: 'tuple[str, ...]' = (), start: 'float | None' = None, end: 'float | None' = None, price_basis: 'PriceBasis | None' = None, as_of: 'float | None' = None) -> None",
      "DataSelection": "class alphalab.api.DataSelection(records: 'tuple[CanonicalRecord, ...]', dataset_version: 'str | None', request: 'DataRequest') -> None",
      "EventColumns": "class alphalab.api.EventColumns(subject: 'str', event_type: 'str', observed_at: 'str', availability: 'AvailabilityRule', measurements: 'tuple[str, ...]', attributes: 'tuple[str, ...]', effective_at: 'str | None', revision: 'str | None', ingested_at_retrieval: 'bool') -> None",
      "FundamentalColumns": "class alphalab.api.FundamentalColumns(subject: 'str', statement: 'str', line_item: 'str', fiscal_year: 'str', fiscal_quarter: 'str', period_start: 'str', period_end: 'str', value: 'str', unit: 'str', published_at: 'str', availability: 'AvailabilityRule', revision: 'str | None', ingested_at_retrieval: 'bool') -> None",
      "ObservationColumns": "class alphalab.api.ObservationColumns(category: 'str', unit: 'str', subject: 'str', metric: 'str', value: 'str', observed_at: 'str', availability: 'AvailabilityRule', effective_at: 'str | None', revision: 'str | None', period: 'tuple[str, str, str] | None', ingested_at_retrieval: 'bool') -> None",
      "PointInTimeIngestion": "class alphalab.api.PointInTimeIngestion(observations: 'ObservationSet[T]', rejected: 'tuple[RowRejection, ...]') -> None",
      "ResearchEngine": "class alphalab.research.engine.ResearchEngine()",
      "ResearchStudy": "class alphalab.research.study.ResearchStudy(study_name: 'str', dataset_version: 'str | None', universe: 'tuple[str, ...]', features: 'tuple[FeatureDefinition, ...]', horizons: 'tuple[int, ...]' = (), splits: 'str' = '', parameters: 'Mapping[str, float]' = <factory>, seed: 'int | None' = None, notes: 'str' = '', inputs: 'Mapping[str, str]' = <factory>, implementation_lag: 'int | None' = None) -> None",
      "StudyResult": "class alphalab.research.study.StudyResult(result_id: 'str', study: 'ResearchStudy', metrics: 'Mapping[str, float]' = <factory>, splits: 'SplitReport | None' = None, feature_lineage: 'Mapping[str, str]' = <factory>, findings: 'tuple[str, ...]' = <factory>, warnings: 'tuple[str, ...]' = <factory>, produced_at: 'float' = 0.0) -> None",
      "TimestampReading": "class alphalab.api.TimestampReading(timestamp_format: 'TimestampFormat', timezone_name: 'str | None', date_policy: 'DateOnlyPolicy | None') -> None",
      "WireTimestamp": "enum alphalab.api.WireTimestamp[AVAILABILITY, OBSERVATION]",
      "backtest": "function alphalab.api.backtest(config: 'RunConfig', dataset: 'Dataset', strategy_state: 'StrategyRuntimeState', context_factory: 'ContextFactory', policy: 'NormalizationPolicy') -> 'BacktestResult'",
      "clean_dataset": "function alphalab.api.clean_dataset(dataset: 'Dataset', policy: 'CleaningPolicy') -> 'tuple[tuple[CanonicalRecord, ...], DataQualityReport]'",
      "convention_from_spec": "function alphalab.api.convention_from_spec(spec: 'EquitySpec | FutureSpec | OptionSpec', calendar_id: 'str', tick: 'TickSchedule', lot: 'LotSpecification', settlement: 'SettlementRule', settlement_currency: 'str | None' = None) -> 'MarketConvention'",
      "currency_classification": "function alphalab.api.currency_classification(registry: 'InstrumentRegistry', asset_ids: 'Sequence[str]') -> 'Classification'",
      "future_contract_from_spec": "function alphalab.api.future_contract_from_spec(spec: 'FutureSpec', currency: 'str | None' = None) -> 'FutureContract'",
      "ingest_csv": "function alphalab.api.ingest_csv(path: 'str | Path', request: 'IngestionRequest', encoding: 'str' = 'utf-8', dialect: 'CsvDialect | None' = None) -> 'IngestionResult'",
      "ingest_events": "function alphalab.api.ingest_events(rows: 'Sequence[Mapping[str, object]]', name: 'str', source: 'ObservationSource', columns: 'EventColumns', reading: 'TimestampReading') -> 'PointInTimeIngestion[InformationEvent]'",
      "ingest_fundamentals": "function alphalab.api.ingest_fundamentals(rows: 'Sequence[Mapping[str, object]]', name: 'str', source: 'ObservationSource', columns: 'FundamentalColumns', reading: 'TimestampReading') -> 'PointInTimeIngestion[FundamentalObservation]'",
      "ingest_observations": "function alphalab.api.ingest_observations(rows: 'Sequence[Mapping[str, object]]', name: 'str', source: 'ObservationSource', columns: 'ObservationColumns', reading: 'TimestampReading') -> 'PointInTimeIngestion[ExternalObservation]'",
      "ingest_rows": "function alphalab.api.ingest_rows(rows: 'Sequence[Mapping[str, object]]', request: 'IngestionRequest') -> 'IngestionResult'",
      "inspect_csv": "function alphalab.api.inspect_csv(path: 'str | Path', retrieved_at: 'float', encoding: 'str' = 'utf-8', dialect: 'CsvDialect | None' = None) -> 'tuple[RawSource, RawTable, SchemaDetection]'",
      "lift_wire_records": "function alphalab.api.lift_wire_records(records: 'Sequence[CanonicalRecord]', name: 'str', source: 'ObservationSource', meaning: 'WireTimestamp', unit: 'str') -> 'ObservationSet[ExternalObservation]'",
      "normalize_records": "function alphalab.api.normalize_records(records: 'Sequence[CanonicalRecord]', policy: 'NormalizationPolicy') -> 'tuple[MarketInput, ...]'",
      "observation_source": "function alphalab.api.observation_source(raw: 'RawSource', source_id: 'str', version: 'str | None', quality: 'DataProvenance | None' = None) -> 'ObservationSource'",
      "observe": "function alphalab.api.observe(dataset: 'Dataset', source_field: 'FeatureField') -> 'ObservationFrame'",
      "option_contract_from_spec": "function alphalab.api.option_contract_from_spec(spec: 'OptionSpec') -> 'OptionContract'",
      "replay": "function alphalab.api.replay(config: 'RunConfig', dataset: 'Dataset', strategy_state: 'StrategyRuntimeState', context_factory: 'ContextFactory', policy: 'NormalizationPolicy', *, pause_when: 'Callable[[ReplayProgress], bool] | None' = None) -> 'ReplayResult | PausedReplay'",
      "resume_replay": "function alphalab.api.resume_replay(paused: 'PausedReplay', context_factory: 'ContextFactory', *, pause_when: 'Callable[[ReplayProgress], bool] | None' = None) -> 'ReplayResult | PausedReplay'",
      "run_study": "function alphalab.api.run_study(study: 'ResearchStudy', dataset: 'Dataset', price_field: 'FeatureField' = <FeatureField.CLOSE: 4>, buckets: 'int' = 5, minimum_assets: 'int' = 5, produced_at: 'float' = 0.0, *, delistings: 'Sequence[DelistingReturn]') -> 'StudyResult'",
      "sector_classification": "function alphalab.api.sector_classification(registry: 'InstrumentRegistry', asset_ids: 'Sequence[str]', as_of: 'float | None') -> 'Classification'",
      "select": "function alphalab.api.select(dataset: 'Dataset', request: 'DataRequest') -> 'DataSelection'",
      "study_panels": "function alphalab.api.study_panels(study: 'ResearchStudy', dataset: 'Dataset') -> 'dict[str, FeaturePanel]'",
      "to_market_dataset": "function alphalab.api.to_market_dataset(dataset: 'Dataset', policy: 'NormalizationPolicy') -> 'MarketDataset'",
      "validate_dataset": "function alphalab.api.validate_dataset(dataset: 'Dataset') -> 'tuple[ValidationFinding, ...]'"
    },
    "alphalab.backtesting": {
      "BacktestEngine": "class alphalab.backtesting.engine.BacktestEngine()",
      "BacktestError": "class alphalab.backtesting.exceptions.BacktestError",
      "BacktestResult": "class alphalab.backtesting.state.BacktestResult(run: 'RunState') -> None",
      "DatasetValidationError": "class alphalab.backtesting.exceptions.DatasetValidationError",
      "ExecutionMode": "enum alphalab.runtime.run.ExecutionMode[BACKTEST, REPLAY, PAPER, LIVE]",
      "FillDecision": "class alphalab.execution.policy.FillDecision(status: alphalab.execution.fill.FillStatus, quantity: decimal.Decimal | None = None) -> None",
      "FillPolicy": "class alphalab.execution.policy.FillPolicy(*args, **kwargs)",
      "ImmediateFill": "class alphalab.execution.policy.ImmediateFill() -> None",
      "LiquidityCappedFill": "class alphalab.execution.policy.LiquidityCappedFill(participation_rate: decimal.Decimal = Decimal('1')) -> None",
      "LiquidityContext": "class alphalab.execution.policy.LiquidityContext(asset_id: str, side: alphalab.core.enums.Side, requested_quantity: decimal.Decimal, price: decimal.Decimal, available_quantity: decimal.Decimal | None, timestamp: float) -> None",
      "MarketDataset": "class alphalab.backtesting.dataset.MarketDataset(dataset_id: 'str', records: 'tuple[MarketRecord, ...]') -> None",
      "MarketInput": "alias alphalab.market.quote.Quote | alphalab.market.bar.Bar | alphalab.market.tick.Tick",
      "MarketRecord": "class alphalab.market.record.MarketRecord(event_id: 'str', timestamp: 'float', payload: 'MarketInput') -> None",
      "PausedReplay": "class alphalab.backtesting.replay.PausedReplay(run: 'RunState', cursor: 'ReplayState', cursor_position: 'IdStreamPosition') -> None",
      "ReplayBacktest": "class alphalab.backtesting.replay.ReplayBacktest()",
      "ReplayProgress": "class alphalab.backtesting.replay.ReplayProgress(records_replayed: 'int', records_total: 'int', next_timestamp: 'float') -> None",
      "ReplayResult": "class alphalab.backtesting.state.ReplayResult(backtest: 'BacktestResult', replay_status: 'str', records_replayed: 'int', last_record: 'MarketRecord | None') -> None",
      "RunConfig": "class alphalab.runtime.run.RunConfig(pipeline: 'ExecutionPipelineConfig', mode: 'ExecutionMode', fill_policy: 'FillPolicy' = <factory>, seed: 'int | None' = None, start_timestamp: 'float' = 0.0, ordering: 'OrderingGuarantee' = <OrderingGuarantee.CHRONOLOGICAL: 1>, max_market_data_age_seconds: 'float | None' = None, years_elapsed: 'float | None' = None, risk_free_rate: 'float' = 0.0, compile_analytics: 'bool' = True, periods_per_year: 'float | None' = None, halt_on_strategy_failure: 'bool' = False) -> None",
      "RunState": "class alphalab.runtime.run.RunState(config: 'RunConfig', pipeline: 'ExecutionPipelineState', processed: 'int' = 0, current_timestamp: 'float' = 0.0, last_record_timestamp: 'float | None' = None, source_id: 'str | None' = None, steps: 'AppendOnlyLog[RunStep]' = <factory>, skipped: 'AppendOnlyLog[SkippedRecord]' = <factory>, last_slice_at: 'float | None' = None, observations_delivered: 'int' = 0, last_observation: 'tuple[float, str] | None' = None) -> None",
      "RunStep": "class alphalab.runtime.run.RunStep(index: 'int', event_id: 'str', timestamp: 'float', orders: 'tuple[OMSOrder, ...]', reports: 'tuple[ExecutionReport, ...]', fills: 'tuple[CoreFill, ...]', equity: 'Decimal') -> None",
      "StaticFill": "class alphalab.execution.policy.StaticFill(status: alphalab.execution.fill.FillStatus = <FillStatus.FULL_FILL: 1>, quantity: decimal.Decimal | None = None) -> None",
      "UnpricedAsset": "class alphalab.runtime.execution_pipeline.UnpricedAsset(asset_id: 'str', reason: 'UnpricedReason', detail: 'str', first_timestamp: 'float', last_timestamp: 'float', occurrences: 'int') -> None",
      "UnpricedReason": "enum alphalab.runtime.execution_pipeline.UnpricedReason[NO_PRICE_OBSERVED, NOT_REGISTERED, REGISTERED_BUT_UNPRICED]",
      "UnsupportedRecordError": "class alphalab.market.exceptions.UnsupportedRecordError",
      "advance": "function alphalab.backtesting.engine.advance(state: 'RunState', record: 'MarketRecord', context_factory: 'ContextFactory') -> 'tuple[RunState, ExecutionPipelineResult | None]'",
      "commission_paid": "function alphalab.backtesting.views.commission_paid(result: alphalab.backtesting.state.BacktestResult) -> decimal.Decimal",
      "equity_values": "function alphalab.backtesting.views.equity_values(result: alphalab.backtesting.state.BacktestResult) -> tuple[decimal.Decimal, ...]",
      "executed_fills": "function alphalab.backtesting.views.executed_fills(result: alphalab.backtesting.state.BacktestResult) -> collections.abc.Sequence[alphalab.core.fill.Fill]",
      "final_cash": "function alphalab.backtesting.views.final_cash(result: alphalab.backtesting.state.BacktestResult) -> decimal.Decimal",
      "final_equity": "function alphalab.backtesting.views.final_equity(result: alphalab.backtesting.state.BacktestResult) -> decimal.Decimal",
      "finalize": "function alphalab.backtesting.engine.finalize(state: 'RunState') -> 'BacktestResult'",
      "id_scope": "function alphalab.common.ids.id_scope(seed: int | None) -> contextlib.AbstractContextManager[None]",
      "id_source": "function alphalab.common.ids.id_source(seed: int | None) -> collections.abc.Callable[[], str] | None",
      "initialize": "function alphalab.backtesting.engine.initialize(config: 'RunConfig', strategy_state: 'StrategyRuntimeState') -> 'RunState'",
      "performance_report": "function alphalab.backtesting.views.performance_report(result: alphalab.backtesting.state.BacktestResult) -> alphalab.analytics.report.PerformanceReport | None",
      "publish": "function alphalab.backtesting.engine.publish(market: 'MarketState', record: 'MarketRecord') -> 'MarketState'",
      "realized_pnl": "function alphalab.backtesting.views.realized_pnl(result: alphalab.backtesting.state.BacktestResult) -> decimal.Decimal",
      "session_for": "function alphalab.backtesting.replay.session_for(dataset: 'MarketDataset', speed_multiplier: 'float' = 1.0) -> 'ReplaySession'",
      "steps_with_fills": "function alphalab.backtesting.views.steps_with_fills(result: alphalab.backtesting.state.BacktestResult) -> collections.abc.Sequence[alphalab.runtime.run.RunStep]",
      "submitted_orders": "function alphalab.backtesting.views.submitted_orders(result: alphalab.backtesting.state.BacktestResult) -> collections.abc.Sequence[alphalab.oms.order.Order]",
      "unrealized_pnl": "function alphalab.backtesting.views.unrealized_pnl(result: alphalab.backtesting.state.BacktestResult) -> decimal.Decimal",
      "validate_dataset": "function alphalab.backtesting.dataset.validate_dataset(dataset: 'MarketDataset') -> 'None'"
    },
    "alphalab.backtesting.replay_snapshot": {
      "REPLAY_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "REPLAY_SNAPSHOT_SCHEMA": "value builtins.int",
      "ReplayEventRecord": "class alphalab.backtesting.replay_snapshot.ReplayEventRecord(event_type: 'str', event: 'ReplaySystemEvent') -> None",
      "ReplaySnapshot": "class alphalab.backtesting.replay_snapshot.ReplaySnapshot(run: 'RunSnapshot', session: 'ReplaySession', status: 'ReplayStatus', current_index: 'int', current_timestamp: 'float', real_start_time: 'float', real_current_time: 'float', events: 'tuple[ReplayEventRecord, ...]', cursor_position: 'IdStreamPosition', records_total: 'int', dataset_digest: 'str', last_event_id: 'str | None', next_event_id: 'str', events_dropped: 'int' = 0, schema_version: 'int' = 1) -> None",
      "capture": "function alphalab.backtesting.replay_snapshot.capture(paused: 'PausedReplay') -> 'ReplaySnapshot'",
      "dataset_digest": "function alphalab.backtesting.replay_snapshot.dataset_digest(dataset: 'MarketDataset') -> 'str'",
      "from_primitives": "function alphalab.backtesting.replay_snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'ReplaySnapshot'",
      "restore": "function alphalab.backtesting.replay_snapshot.restore(snapshot: 'ReplaySnapshot', objects: 'RunObjects', dataset: 'MarketDataset') -> 'PausedReplay'"
    },
    "alphalab.broker": {
      "ANY_LISTING_VENUE": "value builtins.str",
      "AccountCapability": "class alphalab.core.capabilities.AccountCapability(account_id: 'str', asset_classes: 'frozenset[AssetType]', margin: 'Support', short_selling: 'Support') -> None",
      "BROKER_LOCAL_EQUIVALENTS": "value builtins.mappingproxy",
      "BROKER_STATUS_EQUIVALENTS": "value builtins.mappingproxy",
      "BrokerAccount": "class alphalab.broker.account.BrokerAccount(account_id: str, cash: decimal.Decimal, equity: decimal.Decimal, buying_power: decimal.Decimal, margin: decimal.Decimal, available_funds: decimal.Decimal, currency: str, broker_id: str = '', metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "BrokerAdapter": "class alphalab.broker.adapter.BrokerAdapter()",
      "BrokerAssetClass": "enum alphalab.core.enums.AssetType[EQUITY, FUTURE, OPTION, FOREX, CRYPTO, CASH]",
      "BrokerConnected": "class alphalab.broker.events.BrokerConnected(event_id: str, timestamp: float, broker_name: str) -> None",
      "BrokerDisconnected": "class alphalab.broker.events.BrokerDisconnected(event_id: str, timestamp: float, broker_name: str, reason: str) -> None",
      "BrokerEngine": "class alphalab.broker.broker.BrokerEngine()",
      "BrokerError": "class alphalab.broker.exceptions.BrokerError",
      "BrokerEvent": "class alphalab.broker.events.BrokerEvent(event_id: str, timestamp: float) -> None",
      "BrokerExecution": "class alphalab.broker.execution.BrokerExecution(execution_id: str, broker_order_id: str, symbol: str, fill_quantity: decimal.Decimal, fill_price: decimal.Decimal, commission: decimal.Decimal, timestamp: float, account_id: str = '', external_id: str = '') -> None",
      "BrokerOrder": "class alphalab.broker.order.BrokerOrder(broker_order_id: str, oms_order_id: str, symbol: str, side: alphalab.core.enums.Side, order_type: alphalab.common.order_terms.OrderType, quantity: decimal.Decimal, price: decimal.Decimal, filled_quantity: decimal.Decimal, average_fill_price: decimal.Decimal, status: alphalab.core.enums.OrderStatus | alphalab.broker.order.BrokerOrderStatus, created_at: float, updated_at: float, account_id: str = '', tif: alphalab.common.order_terms.TimeInForce = <TimeInForce.DAY: 'day'>, stop_price: decimal.Decimal = Decimal('0')) -> None",
      "BrokerOrderSide": "enum alphalab.core.enums.Side[BUY, SELL]",
      "BrokerOrderStatus": "enum alphalab.broker.order.BrokerOrderStatus[PENDING_SUBMIT, SUBMITTED, PENDING_CANCEL]",
      "BrokerOrderType": "enum alphalab.common.order_terms.OrderType[MARKET, LIMIT, STOP, STOP_LIMIT]",
      "BrokerPosition": "class alphalab.broker.position.BrokerPosition(symbol: str, quantity: decimal.Decimal, average_price: decimal.Decimal, market_value: decimal.Decimal, unrealized_pnl: decimal.Decimal, realized_pnl: decimal.Decimal, account_id: str = '', asset_class: alphalab.core.enums.AssetType = <AssetType.EQUITY: 'equity'>, market_price: decimal.Decimal = Decimal('0')) -> None",
      "BrokerProtocol": "class alphalab.broker.protocol.BrokerProtocol(*args, **kwargs)",
      "BrokerState": "class alphalab.broker.state.BrokerState(broker_name: str, connection_status: alphalab.broker.state.ConnectionStatus, account: alphalab.broker.account.BrokerAccount, positions: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.position.BrokerPosition] = <factory>, orders: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.order.BrokerOrder] = <factory>, executions: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.execution.BrokerExecution] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.broker.events.BrokerEvent] = <factory>, metadata: collections.abc.Mapping[str, str] = <factory>, last_heartbeat: float = 0.0, venue_sequences: alphalab.common.persistent_map.PersistentMap[str, int] = <factory>) -> None",
      "BrokerTimeInForce": "enum alphalab.common.order_terms.TimeInForce[DAY, GTC, IOC, FOK, GTD, OPG, CLS]",
      "BrokerValidationError": "class alphalab.broker.exceptions.BrokerValidationError",
      "CancelRequest": "class alphalab.broker.requests.CancelRequest(broker_order_id: 'str', attempt: 'int', requested_at: 'float') -> None",
      "Capability": "enum alphalab.core.capabilities.Capability[MARKET_ORDERS, LIMIT_ORDERS, STOP_ORDERS, STOP_LIMIT_ORDERS, SHORTING, OPTIONS, FUTURES, FRACTIONAL, MARGIN, STREAMING, CANCEL_REPLACE, BRACKET_ORDERS, EXTENDED_HOURS]",
      "CapabilityCheck": "class alphalab.core.capabilities.CapabilityCheck(dimension: 'RequirementDimension', level: 'CapabilityLevel', requirement: 'str', capability: 'Capability | None', support: 'Support', detail: 'str') -> None",
      "CapabilityDeclaration": "class alphalab.core.capabilities.CapabilityDeclaration(adapter_id: 'str', supported_features: 'frozenset[Capability]', unsupported_features: 'frozenset[Capability]', markets: 'tuple[MarketCapability, ...]', unsupported_asset_classes: 'frozenset[AssetType]', accounts: 'tuple[AccountCapability, ...]') -> None",
      "CapabilityLevel": "enum alphalab.core.capabilities.CapabilityLevel[VENUE, MARKET, ACCOUNT]",
      "Compatibility": "enum alphalab.core.capabilities.Compatibility[COMPATIBLE, INCOMPATIBLE, UNDETERMINED]",
      "CompatibilityReport": "class alphalab.core.capabilities.CompatibilityReport(requirements: 'ExecutionRequirements', adapter_id: 'str', declaration_id: 'str', checks: 'tuple[CapabilityCheck, ...]') -> None",
      "ConnectionStatus": "enum alphalab.broker.state.ConnectionStatus[DISCONNECTED, CONNECTING, CONNECTED, RECONNECTING, FAILED]",
      "ExecutionDecision": "class alphalab.broker.reconciliation.ExecutionDecision(outcome: 'ExecutionOutcome', execution: 'BrokerExecution', reason: 'str') -> None",
      "ExecutionEventKind": "enum alphalab.core.lifecycle.ExecutionEventKind[ORDER_ACCEPTED, ORDER_REJECTED, ORDER_PARTIALLY_FILLED, ORDER_FILLED, ORDER_CANCELLED, ORDER_EXPIRED, ORDER_REPLACED, ORDER_CANCEL_REJECTED, POSITION_CHANGED, BALANCE_CHANGED, BROKER_DISCONNECTED, BROKER_CONNECTED]",
      "ExecutionOutcome": "enum alphalab.broker.reconciliation.ExecutionOutcome[APPLIED, DUPLICATE, UNKNOWN_ORDER, TERMINAL_ORDER, OVERFILL, INVALID]",
      "ExecutionReceived": "class alphalab.broker.events.ExecutionReceived(event_id: str, timestamp: float, execution_id: str, broker_order_id: str, fill_quantity: decimal.Decimal, fill_price: decimal.Decimal) -> None",
      "ExecutionRequirements": "class alphalab.core.capabilities.ExecutionRequirements(asset_class: 'AssetType', listing_venue: 'str', account_id: 'str', order_types: 'frozenset[OrderType]', time_in_force: 'frozenset[TimeInForce]', short_selling: 'bool', fractional_quantities: 'bool', extended_hours: 'bool', bracket_orders: 'bool', margin: 'bool', features: 'frozenset[Capability]') -> None",
      "ExternalOrderMap": "class alphalab.broker.reconciliation.ExternalOrderMap(to_broker: 'PersistentMap[str, str]' = <factory>, to_oms: 'PersistentMap[str, str]' = <factory>) -> None",
      "Heartbeat": "class alphalab.broker.events.Heartbeat(event_id: str, timestamp: float, broker_name: str) -> None",
      "InvalidBrokerStateError": "class alphalab.broker.exceptions.InvalidBrokerStateError",
      "LifecycleDecision": "class alphalab.broker.lifecycle.LifecycleDecision(event: 'VenueEvent', outcome: 'LifecycleOutcome', reason: 'str', status_before: 'OrderStatus | BrokerOrderStatus | None' = None, status_after: 'OrderStatus | BrokerOrderStatus | None' = None, implied: 'tuple[ExecutionEventKind, ...]' = (), execution: 'ExecutionDecision | None' = None) -> None",
      "LifecycleOutcome": "enum alphalab.broker.lifecycle.LifecycleOutcome[APPLIED, DUPLICATE, STALE, CONFLICT, UNKNOWN_ORDER, INVALID]",
      "MarketCapability": "class alphalab.core.capabilities.MarketCapability(asset_class: 'AssetType', listing_venue: 'str', order_types: 'frozenset[OrderType]', time_in_force: 'frozenset[TimeInForce]', short_selling: 'Support', fractional_quantities: 'Support', extended_hours: 'Support', bracket_orders: 'Support') -> None",
      "ModifyRequest": "class alphalab.broker.requests.ModifyRequest(broker_order_id: 'str', revision: 'int', quantity: 'Decimal', price: 'Decimal', requested_at: 'float') -> None",
      "OMSOrderProtocol": "class alphalab.broker.adapter.OMSOrderProtocol(*args, **kwargs)",
      "OrderAccepted": "class alphalab.broker.events.OrderAccepted(event_id: str, timestamp: float, broker_order_id: str) -> None",
      "OrderCancelled": "class alphalab.broker.events.OrderCancelled(event_id: str, timestamp: float, broker_order_id: str) -> None",
      "OrderDivergence": "class alphalab.broker.reconciliation.OrderDivergence(broker_order_id: 'str', local: 'BrokerOrder | None', remote: 'BrokerOrder | None', reason: 'str') -> None",
      "OrderRejected": "class alphalab.broker.events.OrderRejected(event_id: str, timestamp: float, broker_order_id: str, reason: str) -> None",
      "OrderSubmitted": "class alphalab.broker.events.OrderSubmitted(event_id: str, timestamp: float, broker_order_id: str, oms_order_id: str) -> None",
      "PaperBroker": "class alphalab.broker.paper.PaperBroker(cost_model: alphalab.execution.costs.ExecutionCostModel) -> None",
      "PositionDivergence": "class alphalab.broker.reconciliation.PositionDivergence(symbol: 'str', local_quantity: 'Decimal', remote_quantity: 'Decimal') -> None",
      "ReconciliationLog": "class alphalab.broker.reconciliation.ReconciliationLog(breaks: 'AppendOnlyLog[ExecutionDecision]' = <factory>, duplicates: 'AppendOnlyLog[ExecutionDecision]' = <factory>) -> None",
      "ReconciliationReport": "class alphalab.broker.reconciliation.ReconciliationReport(missing_at_broker: 'tuple[OrderDivergence, ...]' = <factory>, unknown_locally: 'tuple[OrderDivergence, ...]' = <factory>, divergent_orders: 'tuple[OrderDivergence, ...]' = <factory>, divergent_positions: 'tuple[PositionDivergence, ...]' = <factory>, cash_difference: 'Decimal' = Decimal('0')) -> None",
      "RequestDecision": "class alphalab.broker.requests.RequestDecision(request: 'CancelRequest | ModifyRequest', outcome: 'RequestOutcome', reason: 'str') -> None",
      "RequestLedger": "class alphalab.broker.requests.RequestLedger(issued: 'PersistentMap[str, CancelRequest | ModifyRequest]' = <factory>, latest_cancel: 'PersistentMap[str, tuple[int, str]]' = <factory>, latest_revision: 'PersistentMap[str, tuple[int, str]]' = <factory>) -> None",
      "RequestOutcome": "enum alphalab.broker.requests.RequestOutcome[NEW, DUPLICATE, REFUSED]",
      "RequirementDimension": "enum alphalab.core.capabilities.RequirementDimension[MARKET, ORDER_TYPE, TIME_IN_FORCE, EXECUTION_FEATURE, ACCOUNT, RISK]",
      "SNAPSHOT_RECONCILIATION_SCHEME": "value builtins.str",
      "SnapshotDivergence": "class alphalab.broker.reconciliation.SnapshotDivergence(kind: 'SnapshotDivergenceKind', key: 'str', local: 'str | None', remote: 'str | None', reason: 'str') -> None",
      "SnapshotDivergenceKind": "enum alphalab.broker.reconciliation.SnapshotDivergenceKind[MISSING_ORDER, UNKNOWN_ORDER, ORDER_QUANTITY, ORDER_PRICE, ORDER_FILLED_QUANTITY, ORDER_STATUS, MISSING_EXECUTION, UNKNOWN_EXECUTION, EXECUTION_MISMATCH, POSITION_QUANTITY, BALANCE, ACCOUNT_IDENTITY, DUPLICATE_EVIDENCE]",
      "SnapshotFreshness": "enum alphalab.broker.reconciliation.SnapshotFreshness[CURRENT, PREDATES_MIRROR, TOO_OLD, FROM_THE_FUTURE]",
      "SnapshotReconciliation": "class alphalab.broker.reconciliation.SnapshotReconciliation(snapshot_id: 'str', as_of: 'float', evaluated_at: 'float', max_age_seconds: 'float', freshness: 'SnapshotFreshness', divergences: 'tuple[SnapshotDivergence, ...]', unexamined: 'tuple[str, ...]', compared_orders: 'int', compared_executions: 'int', compared_positions: 'int') -> None",
      "Support": "enum alphalab.core.capabilities.Support[SUPPORTED, UNSUPPORTED, UNDECLARED]",
      "VENUE_REQUEST_SCHEME": "value builtins.str",
      "VENUE_SNAPSHOT_SCHEME": "value builtins.str",
      "VenueEvent": "class alphalab.broker.lifecycle.VenueEvent(kind: 'ExecutionEventKind', timestamp: 'float', broker_order_id: 'str' = '', execution: 'BrokerExecution | None' = None, quantity: 'Decimal | None' = None, price: 'Decimal | None' = None, position: 'BrokerPosition | None' = None, account: 'BrokerAccount | None' = None, reason: 'str' = '', sequence: 'int | None' = None) -> None",
      "VenueSnapshot": "class alphalab.broker.reconciliation.VenueSnapshot(as_of: 'float', orders: 'tuple[BrokerOrder, ...]', executions: 'tuple[BrokerExecution, ...] | None', positions: 'tuple[BrokerPosition, ...] | None', account: 'BrokerAccount | None') -> None",
      "account_snapshot": "function alphalab.broker.views.account_snapshot(state: alphalab.broker.state.BrokerState) -> alphalab.broker.account.BrokerAccount",
      "apply_execution": "function alphalab.broker.reconciliation.apply_execution(state: 'BrokerState', execution: 'BrokerExecution', log: 'ReconciliationLog | None' = None) -> 'tuple[BrokerState, ExecutionDecision, ReconciliationLog]'",
      "apply_venue_event": "function alphalab.broker.lifecycle.apply_venue_event(state: 'BrokerState', event: 'VenueEvent') -> 'tuple[BrokerState, LifecycleDecision]'",
      "apply_venue_events": "function alphalab.broker.lifecycle.apply_venue_events(state: 'BrokerState', events: 'Iterable[VenueEvent]') -> 'tuple[BrokerState, tuple[LifecycleDecision, ...]]'",
      "canonical_status": "function alphalab.broker.order.canonical_status(status: alphalab.core.enums.OrderStatus | alphalab.broker.order.BrokerOrderStatus) -> alphalab.core.enums.OrderStatus",
      "check_compatibility": "function alphalab.core.capabilities.check_compatibility(requirements: 'ExecutionRequirements', declaration: 'CapabilityDeclaration') -> 'CompatibilityReport'",
      "classify_execution": "function alphalab.broker.reconciliation.classify_execution(state: 'BrokerState', execution: 'BrokerExecution') -> 'ExecutionDecision'",
      "classify_venue_event": "function alphalab.broker.lifecycle.classify_venue_event(state: 'BrokerState', event: 'VenueEvent') -> 'LifecycleDecision'",
      "executions": "function alphalab.broker.views.executions(state: alphalab.broker.state.BrokerState) -> collections.abc.Sequence[alphalab.broker.execution.BrokerExecution]",
      "issue_cancel": "function alphalab.broker.requests.issue_cancel(state: 'BrokerState', ledger: 'RequestLedger', request: 'CancelRequest') -> 'tuple[BrokerState, RequestLedger, RequestDecision]'",
      "issue_modify": "function alphalab.broker.requests.issue_modify(state: 'BrokerState', ledger: 'RequestLedger', request: 'ModifyRequest') -> 'tuple[BrokerState, RequestLedger, RequestDecision]'",
      "open_orders": "function alphalab.broker.views.open_orders(state: alphalab.broker.state.BrokerState) -> collections.abc.Sequence[alphalab.broker.order.BrokerOrder]",
      "order_requirements": "function alphalab.core.capabilities.order_requirements(*, asset_class: 'AssetType', listing_venue: 'str', account_id: 'str', order_type: 'OrderType', time_in_force: 'TimeInForce', side: 'Side', quantity: 'Decimal', position_before: 'Decimal', extended_hours: 'bool', bracket_orders: 'bool', margin: 'bool', features: 'frozenset[Capability]') -> 'ExecutionRequirements'",
      "positions": "function alphalab.broker.views.positions(state: alphalab.broker.state.BrokerState) -> collections.abc.Sequence[alphalab.broker.position.BrokerPosition]",
      "reconcile": "function alphalab.broker.reconciliation.reconcile(state: 'BrokerState', remote_orders: 'Sequence[BrokerOrder]', remote_positions: 'Sequence[BrokerPosition]' = (), remote_account: 'BrokerAccount | None' = None) -> 'ReconciliationReport'",
      "reconcile_snapshot": "function alphalab.broker.reconciliation.reconcile_snapshot(state: 'BrokerState', snapshot: 'VenueSnapshot', *, evaluated_at: 'float', max_age_seconds: 'float') -> 'SnapshotReconciliation'",
      "supports": "function alphalab.core.capabilities.supports(declaration: 'CapabilityDeclaration', capability: 'Capability', *, asset_class: 'AssetType | None' = None, listing_venue: 'str | None' = None, account_id: 'str | None' = None) -> 'Support'",
      "validate_cancel_request": "function alphalab.broker.validation.validate_cancel_request(state: alphalab.broker.state.BrokerState, broker_order_id: str) -> None",
      "validate_execution": "function alphalab.broker.validation.validate_execution(state: alphalab.broker.state.BrokerState, execution_id: str) -> None",
      "validate_order_submission": "function alphalab.broker.validation.validate_order_submission(state: alphalab.broker.state.BrokerState, order: alphalab.broker.order.BrokerOrder) -> None",
      "validate_replace_request": "function alphalab.broker.validation.validate_replace_request(state: alphalab.broker.state.BrokerState, broker_order_id: str, new_quantity: decimal.Decimal, new_price: decimal.Decimal) -> None"
    },
    "alphalab.broker.snapshot": {
      "BROKER_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "BROKER_SNAPSHOT_SCHEMA": "value builtins.int",
      "BrokerEventRecord": "class alphalab.broker.snapshot.BrokerEventRecord(event_type: 'str', event: 'BrokerEvent') -> None",
      "BrokerSnapshot": "class alphalab.broker.snapshot.BrokerSnapshot(broker_name: 'str', connection_status: 'ConnectionStatus', account: 'BrokerAccount', positions: 'tuple[BrokerPosition, ...]' = (), orders: 'tuple[BrokerOrder, ...]' = (), executions: 'tuple[BrokerExecution, ...]' = (), events: 'tuple[BrokerEventRecord, ...]' = (), metadata: 'Mapping[str, str]' = <factory>, last_heartbeat: 'float' = 0.0, order_bindings: 'Mapping[str, str]' = <factory>, breaks: 'tuple[ExecutionDecision, ...]' = (), duplicates: 'tuple[ExecutionDecision, ...]' = (), venue_sequences: 'Mapping[str, int]' = <factory>, schema_version: 'int' = 2) -> None",
      "BrokerSnapshotDecodeError": "class alphalab.broker.snapshot.BrokerSnapshotDecodeError",
      "capture": "function alphalab.broker.snapshot.capture(state: 'BrokerState', mapping: 'ExternalOrderMap | None' = None, log: 'ReconciliationLog | None' = None) -> 'BrokerSnapshot'",
      "from_primitives": "function alphalab.broker.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'BrokerSnapshot'",
      "restore": "function alphalab.broker.snapshot.restore(snapshot: 'BrokerSnapshot') -> 'tuple[BrokerState, ExternalOrderMap, ReconciliationLog]'"
    },
    "alphalab.brokers": {
      "BrokerAccount": "class alphalab.broker.account.BrokerAccount(account_id: str, cash: decimal.Decimal, equity: decimal.Decimal, buying_power: decimal.Decimal, margin: decimal.Decimal, available_funds: decimal.Decimal, currency: str, broker_id: str = '', metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "BrokerConnection": "class alphalab.brokers.connection.BrokerConnection(broker_id: str, broker_name: str, broker_type: alphalab.brokers.connection.BrokerType, connected: bool = False, latency_ms: float = 0.0, last_heartbeat: float = 0.0) -> None",
      "BrokerConnectorAdapter": "class alphalab.brokers.adapter.BrokerConnectorAdapter()",
      "BrokerConnectorEngine": "class alphalab.brokers.engine.BrokerConnectorEngine()",
      "BrokerConnectorError": "class alphalab.brokers.exceptions.BrokerConnectorError",
      "BrokerConnectorEvent": "class alphalab.brokers.events.BrokerConnectorEvent(event_id: str, timestamp: float) -> None",
      "BrokerConnectorProtocol": "class alphalab.brokers.protocol.BrokerConnectorProtocol(*args, **kwargs)",
      "BrokerConnectorState": "class alphalab.brokers.state.BrokerConnectorState(engine_id: str, connections: alphalab.common.persistent_map.PersistentMap[str, alphalab.brokers.connection.BrokerConnection] = <factory>, accounts: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.account.BrokerAccount] = <factory>, positions: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.position.BrokerPosition] = <factory>, orders: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.order.BrokerOrder] = <factory>, executions: alphalab.common.persistent_map.PersistentMap[str, alphalab.broker.execution.BrokerExecution] = <factory>, statistics: alphalab.brokers.state.BrokerStatistics = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.brokers.events.BrokerConnectorEvent] = <factory>, metadata: alphalab.common.persistent_map.PersistentMap[str, str] = <factory>) -> None",
      "BrokerConnectorStateError": "class alphalab.brokers.exceptions.BrokerConnectorStateError",
      "BrokerConnectorValidationError": "class alphalab.brokers.exceptions.BrokerConnectorValidationError",
      "BrokerExecution": "class alphalab.broker.execution.BrokerExecution(execution_id: str, broker_order_id: str, symbol: str, fill_quantity: decimal.Decimal, fill_price: decimal.Decimal, commission: decimal.Decimal, timestamp: float, account_id: str = '', external_id: str = '') -> None",
      "BrokerOrder": "class alphalab.broker.order.BrokerOrder(broker_order_id: str, oms_order_id: str, symbol: str, side: alphalab.core.enums.Side, order_type: alphalab.common.order_terms.OrderType, quantity: decimal.Decimal, price: decimal.Decimal, filled_quantity: decimal.Decimal, average_fill_price: decimal.Decimal, status: alphalab.core.enums.OrderStatus | alphalab.broker.order.BrokerOrderStatus, created_at: float, updated_at: float, account_id: str = '', tif: alphalab.common.order_terms.TimeInForce = <TimeInForce.DAY: 'day'>, stop_price: decimal.Decimal = Decimal('0')) -> None",
      "BrokerOrderStatus": "enum alphalab.broker.order.BrokerOrderStatus[PENDING_SUBMIT, SUBMITTED, PENDING_CANCEL]",
      "BrokerPosition": "class alphalab.broker.position.BrokerPosition(symbol: str, quantity: decimal.Decimal, average_price: decimal.Decimal, market_value: decimal.Decimal, unrealized_pnl: decimal.Decimal, realized_pnl: decimal.Decimal, account_id: str = '', asset_class: alphalab.core.enums.AssetType = <AssetType.EQUITY: 'equity'>, market_price: decimal.Decimal = Decimal('0')) -> None",
      "BrokerRegistered": "class alphalab.brokers.events.BrokerRegistered(event_id: str, timestamp: float, broker_id: str, broker_type: str) -> None",
      "BrokerRegistry": "class alphalab.brokers.registry.BrokerRegistry()",
      "BrokerStatistics": "class alphalab.brokers.state.BrokerStatistics(total_orders_submitted: int = 0, total_executions_received: int = 0, total_errors: int = 0) -> None",
      "BrokerType": "enum alphalab.brokers.connection.BrokerType[PAPER, REST, STREAMING, HYBRID]",
      "OrderManager": "class alphalab.brokers.manager.OrderManager()",
      "OrderSide": "enum alphalab.core.enums.Side[BUY, SELL]",
      "OrderType": "enum alphalab.common.order_terms.OrderType[MARKET, LIMIT, STOP, STOP_LIMIT]",
      "RegisteredBrokerConnected": "class alphalab.brokers.events.RegisteredBrokerConnected(event_id: str, timestamp: float, broker_id: str) -> None",
      "RegisteredBrokerDisconnected": "class alphalab.brokers.events.RegisteredBrokerDisconnected(event_id: str, timestamp: float, broker_id: str, reason: str) -> None",
      "RegisteredBrokerHeartbeat": "class alphalab.brokers.events.RegisteredBrokerHeartbeat(event_id: str, timestamp: float, broker_id: str, latency_ms: float) -> None",
      "RoutedExecutionReceived": "class alphalab.brokers.events.RoutedExecutionReceived(event_id: str, timestamp: float, execution_id: str, broker_order_id: str, fill_price: decimal.Decimal, fill_quantity: decimal.Decimal) -> None",
      "RoutedOrderCancelled": "class alphalab.brokers.events.RoutedOrderCancelled(event_id: str, timestamp: float, broker_order_id: str, account_id: str) -> None",
      "RoutedOrderFilled": "class alphalab.brokers.events.RoutedOrderFilled(event_id: str, timestamp: float, broker_order_id: str, account_id: str, fill_quantity: decimal.Decimal) -> None",
      "RoutedOrderSubmitted": "class alphalab.brokers.events.RoutedOrderSubmitted(event_id: str, timestamp: float, broker_order_id: str, account_id: str, symbol: str) -> None",
      "TimeInForce": "enum alphalab.common.order_terms.TimeInForce[DAY, GTC, IOC, FOK, GTD, OPG, CLS]",
      "active_brokers": "function alphalab.brokers.views.active_brokers(state: alphalab.brokers.state.BrokerConnectorState) -> collections.abc.Sequence[alphalab.brokers.connection.BrokerConnection]",
      "engine_statistics": "function alphalab.brokers.views.engine_statistics(state: alphalab.brokers.state.BrokerConnectorState) -> alphalab.brokers.state.BrokerStatistics",
      "get_account": "function alphalab.brokers.views.get_account(state: alphalab.brokers.state.BrokerConnectorState, account_id: str) -> alphalab.broker.account.BrokerAccount | None",
      "list_executions": "function alphalab.brokers.views.list_executions(state: alphalab.brokers.state.BrokerConnectorState, broker_order_id: str) -> collections.abc.Sequence[alphalab.broker.execution.BrokerExecution]",
      "list_positions": "function alphalab.brokers.views.list_positions(state: alphalab.brokers.state.BrokerConnectorState, account_id: str) -> collections.abc.Sequence[alphalab.broker.position.BrokerPosition]",
      "open_routed_orders": "function alphalab.brokers.views.open_routed_orders(state: alphalab.brokers.state.BrokerConnectorState) -> collections.abc.Sequence[alphalab.broker.order.BrokerOrder]",
      "validate_account": "function alphalab.brokers.validation.validate_account(state: alphalab.brokers.state.BrokerConnectorState, account_id: str, broker_id: str) -> None",
      "validate_broker_registration": "function alphalab.brokers.validation.validate_broker_registration(state: alphalab.brokers.state.BrokerConnectorState, connection: alphalab.brokers.connection.BrokerConnection) -> None",
      "validate_order_cancellation": "function alphalab.brokers.validation.validate_order_cancellation(state: alphalab.brokers.state.BrokerConnectorState, broker_order_id: str) -> alphalab.broker.order.BrokerOrder",
      "validate_routed_execution": "function alphalab.brokers.validation.validate_routed_execution(state: alphalab.brokers.state.BrokerConnectorState, execution_id: str, broker_order_id: str) -> alphalab.broker.order.BrokerOrder",
      "validate_routed_submission": "function alphalab.brokers.validation.validate_routed_submission(state: alphalab.brokers.state.BrokerConnectorState, order: alphalab.broker.order.BrokerOrder) -> None"
    },
    "alphalab.cloud_research": {
      "CloudResearchError": "class alphalab.cloud_research.exceptions.CloudResearchError",
      "CloudResearchInputError": "class alphalab.cloud_research.exceptions.CloudResearchInputError",
      "CloudResearchState": "class alphalab.cloud_research.cluster.CloudResearchState(distributed: alphalab.distributed.state.DistributedState, results: collections.abc.Mapping[str, Any] = <factory>) -> None",
      "collect_sweep": "function alphalab.cloud_research.sweep.collect_sweep(state: alphalab.cloud_research.cluster.CloudResearchState, param_grid: alphalab.research.walk_forward_optimization.ParameterSpace | collections.abc.Mapping[str, collections.abc.Sequence[ParamValue]], job_ids: collections.abc.Sequence[str], metric: str, score: collections.abc.Callable[[Any], float], *, higher_is_better: bool = True) -> alphalab.research.overfitting.SweepResult",
      "initialize_cluster": "function alphalab.cloud_research.cluster.initialize_cluster(cluster_id: str, num_workers: int, capacity_per_worker: int, timestamp: float) -> alphalab.cloud_research.cluster.CloudResearchState",
      "resolve_task": "function alphalab.cloud_research.task.resolve_task(task_path: str) -> collections.abc.Callable[..., Any]",
      "run_cluster_cycle": "function alphalab.cloud_research.cluster.run_cluster_cycle(state: alphalab.cloud_research.cluster.CloudResearchState, executor: concurrent.futures._base.Executor, timestamp: float) -> alphalab.cloud_research.cluster.CloudResearchState",
      "run_task": "function alphalab.cloud_research.task.run_task(payload: collections.abc.Mapping[str, Any]) -> dict[str, Any]",
      "submit_parameter_sweep": "function alphalab.cloud_research.sweep.submit_parameter_sweep(state: alphalab.cloud_research.cluster.CloudResearchState, job_type: alphalab.distributed.job.JobType, task_path: str, param_grid: alphalab.research.walk_forward_optimization.ParameterSpace | collections.abc.Mapping[str, collections.abc.Sequence[ParamValue]], base_kwargs: collections.abc.Mapping[str, Any], priority: int, timestamp: float) -> tuple[alphalab.cloud_research.cluster.CloudResearchState, tuple[str, ...]]",
      "submit_research_job": "function alphalab.cloud_research.cluster.submit_research_job(state: alphalab.cloud_research.cluster.CloudResearchState, job_type: alphalab.distributed.job.JobType, task_path: str, kwargs: collections.abc.Mapping[str, Any], priority: int, timestamp: float) -> tuple[alphalab.cloud_research.cluster.CloudResearchState, str]",
      "sweep_space": "function alphalab.cloud_research.sweep.sweep_space(param_grid: alphalab.research.walk_forward_optimization.ParameterSpace | collections.abc.Mapping[str, collections.abc.Sequence[ParamValue]]) -> alphalab.research.walk_forward_optimization.ParameterSpace"
    },
    "alphalab.cluster_scheduler": {
      "ClusterSchedulerError": "class alphalab.cluster_scheduler.exceptions.ClusterSchedulerError",
      "ClusterSchedulerInputError": "class alphalab.cluster_scheduler.exceptions.ClusterSchedulerInputError",
      "assign_jobs_with_affinity": "function alphalab.cluster_scheduler.affinity_scheduler.assign_jobs_with_affinity(state: alphalab.distributed.state.DistributedState, timestamp: float) -> alphalab.distributed.state.DistributedState",
      "assign_jobs_with_aging": "function alphalab.cluster_scheduler.priority_scheduler.assign_jobs_with_aging(state: alphalab.distributed.state.DistributedState, timestamp: float, aging_rate: float = 0.0) -> alphalab.distributed.state.DistributedState",
      "queue_position": "function alphalab.cluster_scheduler.queue_manager.queue_position(state: alphalab.distributed.state.DistributedState, job_id: str) -> int | None"
    },
    "alphalab.common": {
      "AlphaLabError": "class alphalab.common.exceptions.AlphaLabError",
      "AlphaLabRegistryError": "class alphalab.common.exceptions.AlphaLabRegistryError",
      "AlphaLabSerializationError": "class alphalab.common.exceptions.AlphaLabSerializationError",
      "AlphaLabValidationError": "class alphalab.common.exceptions.AlphaLabValidationError",
      "AppendOnlyLog": "class alphalab.common.append_log.AppendOnlyLog(items: 'Iterable[T]' = ()) -> 'None'",
      "AvailabilityBasis": "enum alphalab.common.point_in_time.AvailabilityBasis[DECLARED, DERIVED, UNKNOWN]",
      "BaseEvent": "class alphalab.common.events.BaseEvent(event_id: str, timestamp: float) -> None",
      "ConversionRecord": "class alphalab.common.currency.ConversionRecord(*args, **kwargs)",
      "CurrencyConverter": "class alphalab.common.currency.CurrencyConverter(*args, **kwargs)",
      "DEFAULT_ENCODING": "value builtins.str",
      "DEFAULT_SCHEMA_VERSION": "value builtins.int",
      "DeterministicIdSource": "class alphalab.common.ids.DeterministicIdSource(seed: int) -> None",
      "Identifier": "newtype alphalab.common.ids.Identifier",
      "LinearFit": "class alphalab.common.statistics.LinearFit(slope: 'float', intercept: 'float', r_squared: 'float | None', observations: 'int', residuals: 'tuple[float, ...]') -> None",
      "MARKET": "value alphalab.common.order_terms.OrderTerms",
      "Metadata": "class alphalab.common.metadata.Metadata(values: collections.abc.Mapping[str, MetadataValue] = <factory>) -> None",
      "MetadataMapping": "alias MetadataMapping",
      "MetadataValue": "alias MetadataValue",
      "OrderTerms": "class alphalab.common.order_terms.OrderTerms(order_type: 'OrderType' = <OrderType.MARKET: 'market'>, limit_price: 'Decimal | None' = None, stop_price: 'Decimal | None' = None, time_in_force: 'TimeInForce' = <TimeInForce.DAY: 'day'>, expire_at: 'float | None' = None) -> None",
      "OrderType": "enum alphalab.common.order_terms.OrderType[MARKET, LIMIT, STOP, STOP_LIMIT]",
      "PACKAGE_NAME": "value builtins.str",
      "ParamValue": "alias ParamValue",
      "PersistentMap": "class alphalab.common.persistent_map.PersistentMap(items: 'Mapping[K, V] | Iterable[tuple[K, V]]' = ()) -> 'None'",
      "PersistentSet": "class alphalab.common.persistent_map.PersistentSet(members: 'Iterable[T]' = ()) -> 'None'",
      "PointInTimeIndex": "class alphalab.common.point_in_time.PointInTimeIndex(visibility: 'VisibilityRule', records: 'tuple[T, ...]', known_instants: 'tuple[float, ...]', unverified: 'tuple[T, ...]') -> None",
      "PointInTimeRecord": "class alphalab.common.point_in_time.PointInTimeRecord(*args, **kwargs)",
      "PointInTimeStamp": "class alphalab.common.point_in_time.PointInTimeStamp(observed_at: 'float', available_at: 'float | None', basis: 'AvailabilityBasis', effective_at: 'float | None' = None, ingested_at: 'float | None' = None, rule: 'str' = '') -> None",
      "RankMethod": "enum alphalab.common.statistics.RankMethod[AVERAGE, MIN, MAX, ORDINAL]",
      "RateRecord": "class alphalab.common.currency.RateRecord(*args, **kwargs)",
      "Result": "class alphalab.common.results.Result(ok: bool, value: ValueT | None = None, error: str | None = None) -> None",
      "StampedRecord": "class alphalab.common.point_in_time.StampedRecord(*args, **kwargs)",
      "TieBreak": "enum alphalab.common.statistics.TieBreak[LOW, HIGH, SPREAD]",
      "TimeInForce": "enum alphalab.common.order_terms.TimeInForce[DAY, GTC, IOC, FOK, GTD, OPG, CLS]",
      "VisibilityRule": "enum alphalab.common.point_in_time.VisibilityRule[PUBLICATION, INGESTION]",
      "__version__": "value builtins.str",
      "bucket_index": "function alphalab.common.statistics.bucket_index(values: 'Sequence[float]', buckets: 'int', tie_break: 'TieBreak' = <TieBreak.LOW: 1>) -> 'tuple[int, ...]'",
      "copy_metadata": "function alphalab.common.metadata.copy_metadata(metadata: MetadataMapping) -> dict[str, MetadataValue]",
      "dataclass_to_dict": "function alphalab.common.serialization.dataclass_to_dict(instance: object) -> dict[str, Any]",
      "ensure_timezone_aware": "function alphalab.common.time.ensure_timezone_aware(value: datetime.datetime, field_name: str = 'timestamp') -> datetime.datetime",
      "generic_known_as_of": "function alphalab.common.point_in_time.known_as_of(records: 'tuple[T, ...]', as_of: 'float') -> 'T | None'",
      "id_scope": "function alphalab.common.ids.id_scope(seed: int | None) -> contextlib.AbstractContextManager[None]",
      "id_source": "function alphalab.common.ids.id_source(seed: int | None) -> collections.abc.Callable[[], str] | None",
      "is_uuid": "function alphalab.common.ids.is_uuid(value: str) -> bool",
      "linear_regression": "function alphalab.common.statistics.linear_regression(ys: 'Sequence[float]', xs: 'Sequence[float]') -> 'LinearFit'",
      "mean": "function alphalab.common.statistics.mean(values: 'Sequence[float]') -> 'float'",
      "median": "function alphalab.common.statistics.median(values: 'Sequence[float]') -> 'float'",
      "new_id": "function alphalab.common.ids.new_id() -> alphalab.common.ids.Identifier",
      "pearson_correlation": "function alphalab.common.statistics.pearson_correlation(xs: 'Sequence[float]', ys: 'Sequence[float]') -> 'float'",
      "percentile": "function alphalab.common.statistics.percentile(values: 'Sequence[float]', fraction: 'float') -> 'float'",
      "rank_correlation": "function alphalab.common.statistics.rank_correlation(xs: 'Sequence[float]', ys: 'Sequence[float]') -> 'float'",
      "ranks": "function alphalab.common.statistics.ranks(values: 'Sequence[float]', method: 'RankMethod' = <RankMethod.AVERAGE: 1>) -> 'tuple[float, ...]'",
      "require_non_empty_string": "function alphalab.common.validators.require_non_empty_string(value: str, field_name: str, *, message: str | None = None, exception_type: type[Exception] = <class 'alphalab.common.exceptions.AlphaLabValidationError'>) -> str",
      "require_non_negative_int": "function alphalab.common.validators.require_non_negative_int(value: int, field_name: str) -> int",
      "require_positive_int": "function alphalab.common.validators.require_positive_int(value: int, field_name: str) -> int",
      "require_type": "function alphalab.common.validators.require_type(value: object, expected_type: type[T], field_name: str) -> T",
      "require_uuid": "function alphalab.common.ids.require_uuid(value: str, field_name: str) -> alphalab.common.ids.Identifier",
      "sample_variance": "function alphalab.common.statistics.sample_variance(values: 'Sequence[float]') -> 'float'",
      "standard_deviation": "function alphalab.common.statistics.standard_deviation(values: 'Sequence[float]') -> 'float'",
      "standardize": "function alphalab.common.statistics.standardize(values: 'Sequence[float]') -> 'tuple[float, ...]'",
      "to_utc": "function alphalab.common.time.to_utc(value: datetime.datetime) -> datetime.datetime",
      "use_id_source": "function alphalab.common.ids.use_id_source(source: collections.abc.Callable[[], str] | None) -> collections.abc.Iterator[None]",
      "utc_now": "function alphalab.common.time.utc_now() -> datetime.datetime",
      "winsorize": "function alphalab.common.statistics.winsorize(values: 'Sequence[float]', lower: 'float', upper: 'float') -> 'tuple[float, ...]'"
    },
    "alphalab.conventions": {
      "CASH_EQUITY": "value alphalab.conventions.economics.InstrumentEconomics",
      "Compounding": "enum alphalab.conventions.rates.Compounding[ANNUAL, SEMI_ANNUAL, QUARTERLY, MONTHLY, CONTINUOUS]",
      "ContractNotional": "class alphalab.conventions.market.ContractNotional(amount: 'Decimal', currency: 'str', quantity: 'Decimal', price: 'Decimal', multiplier: 'Decimal', underlying_units: 'Decimal') -> None",
      "ConventionError": "class alphalab.conventions.exceptions.ConventionError",
      "ConventionInputError": "class alphalab.conventions.exceptions.ConventionInputError",
      "ConventionViolationError": "class alphalab.conventions.exceptions.ConventionViolationError",
      "DayCount": "enum alphalab.conventions.daycount.DayCount[ACT_365_FIXED, ACT_360, THIRTY_360_US]",
      "InstrumentEconomics": "class alphalab.conventions.economics.InstrumentEconomics(multiplier: 'Decimal', settlement: 'SettlementModel', lot: 'LotSpecification | None' = None, minimum_notional: 'Decimal | None' = None, allows_negative_prices: 'bool' = False) -> None",
      "LotSpecification": "class alphalab.conventions.lot.LotSpecification(lot_size: 'Decimal', minimum_quantity: 'Decimal') -> None",
      "MAX_SETTLEMENT_SEARCH_DAYS": "value builtins.int",
      "MarketConvention": "class alphalab.conventions.market.MarketConvention(venue: 'str', calendar_id: 'str', quote_currency: 'str', settlement_currency: 'str', multiplier: 'Decimal', tick: 'TickSchedule', lot: 'LotSpecification', settlement: 'SettlementRule') -> None",
      "RoundingDirection": "enum alphalab.conventions.tick.RoundingDirection[DOWN, UP, NEAREST]",
      "SettlementBasis": "enum alphalab.conventions.settlement.SettlementBasis[TRADE_DATE, TRADING_DAYS, CALENDAR_DAYS]",
      "SettlementModel": "enum alphalab.conventions.economics.SettlementModel[CASH_EQUITY, FUTURES_VARIATION, OPTION_PREMIUM, PERPETUAL]",
      "SettlementRule": "class alphalab.conventions.settlement.SettlementRule(basis: 'SettlementBasis', offset_days: 'int') -> None",
      "TickBand": "class alphalab.conventions.tick.TickBand(upper_bound: 'Decimal | None', tick_size: 'Decimal') -> None",
      "TickSchedule": "class alphalab.conventions.tick.TickSchedule(bands: 'tuple[TickBand, ...]') -> None",
      "TickValue": "class alphalab.conventions.tick.TickValue(amount: 'Decimal', currency: 'str', tick_size: 'Decimal', multiplier: 'Decimal') -> None",
      "TradingDayCalendar": "class alphalab.conventions.settlement.TradingDayCalendar(*args, **kwargs)",
      "compound_factor": "function alphalab.conventions.rates.compound_factor(rate: 'float', years: 'float', compounding: 'Compounding') -> 'float'",
      "contract_notional": "function alphalab.conventions.market.contract_notional(convention: 'MarketConvention', quantity: 'Decimal', price: 'Decimal') -> 'ContractNotional'",
      "day_count_days": "function alphalab.conventions.daycount.day_count_days(start: 'date', end: 'date', basis: 'DayCount') -> 'int'",
      "discount_factor": "function alphalab.conventions.rates.discount_factor(rate: 'float', years: 'float', compounding: 'Compounding') -> 'float'",
      "economics_from_primitives": "function alphalab.conventions.economics.economics_from_primitives(value: 'Any', where: 'str' = 'economics') -> 'InstrumentEconomics'",
      "is_on_tick": "function alphalab.conventions.tick.is_on_tick(price: 'Decimal', tick_size: 'Decimal') -> 'bool'",
      "lots_in": "function alphalab.conventions.lot.lots_in(quantity: 'Decimal', specification: 'LotSpecification') -> 'Decimal'",
      "round_down_to_lot": "function alphalab.conventions.lot.round_down_to_lot(quantity: 'Decimal', specification: 'LotSpecification') -> 'Decimal'",
      "round_to_tick": "function alphalab.conventions.tick.round_to_tick(price: 'Decimal', tick_size: 'Decimal', direction: 'RoundingDirection') -> 'Decimal'",
      "settlement_date": "function alphalab.conventions.settlement.settlement_date(rule: 'SettlementRule', trade_date: 'date', calendar: 'TradingDayCalendar | None') -> 'date'",
      "tick_value": "function alphalab.conventions.tick.tick_value(tick_size: 'Decimal', multiplier: 'Decimal', currency: 'str', price: 'Decimal | None' = None) -> 'TickValue'",
      "year_fraction": "function alphalab.conventions.daycount.year_fraction(start: 'date', end: 'date', basis: 'DayCount') -> 'float'"
    },
    "alphalab.core": {
      "ACCOUNT_EVENT_KINDS": "value builtins.frozenset",
      "ANY_LISTING_VENUE": "value builtins.str",
      "AccountCapability": "class alphalab.core.capabilities.AccountCapability(account_id: 'str', asset_classes: 'frozenset[AssetType]', margin: 'Support', short_selling: 'Support') -> None",
      "AccountId": "newtype alphalab.core.ids.AccountId",
      "AlphaLabCoreError": "class alphalab.core.exceptions.AlphaLabCoreError",
      "AssetId": "newtype alphalab.core.ids.AssetId",
      "AssetType": "enum alphalab.core.enums.AssetType[EQUITY, FUTURE, OPTION, FOREX, CRYPTO, CASH]",
      "CANCEL_REQUESTABLE_STATUSES": "value builtins.frozenset",
      "CAPABILITY_DECLARATION_SCHEME": "value builtins.str",
      "CAPABILITY_LEVELS": "value builtins.mappingproxy",
      "COMPATIBILITY_REPORT_SCHEME": "value builtins.str",
      "CONNECTIVITY_EVENT_KINDS": "value builtins.frozenset",
      "Capability": "enum alphalab.core.capabilities.Capability[MARKET_ORDERS, LIMIT_ORDERS, STOP_ORDERS, STOP_LIMIT_ORDERS, SHORTING, OPTIONS, FUTURES, FRACTIONAL, MARGIN, STREAMING, CANCEL_REPLACE, BRACKET_ORDERS, EXTENDED_HOURS]",
      "CapabilityCheck": "class alphalab.core.capabilities.CapabilityCheck(dimension: 'RequirementDimension', level: 'CapabilityLevel', requirement: 'str', capability: 'Capability | None', support: 'Support', detail: 'str') -> None",
      "CapabilityDeclaration": "class alphalab.core.capabilities.CapabilityDeclaration(adapter_id: 'str', supported_features: 'frozenset[Capability]', unsupported_features: 'frozenset[Capability]', markets: 'tuple[MarketCapability, ...]', unsupported_asset_classes: 'frozenset[AssetType]', accounts: 'tuple[AccountCapability, ...]') -> None",
      "CapabilityLevel": "enum alphalab.core.capabilities.CapabilityLevel[VENUE, MARKET, ACCOUNT]",
      "Compatibility": "enum alphalab.core.capabilities.Compatibility[COMPATIBLE, INCOMPATIBLE, UNDETERMINED]",
      "CompatibilityReport": "class alphalab.core.capabilities.CompatibilityReport(requirements: 'ExecutionRequirements', adapter_id: 'str', declaration_id: 'str', checks: 'tuple[CapabilityCheck, ...]') -> None",
      "DomainValidationError": "class alphalab.core.exceptions.DomainValidationError",
      "EXECUTION_REQUIREMENTS_SCHEME": "value builtins.str",
      "EventClassification": "enum alphalab.core.lifecycle.EventClassification[TRANSITION, DUPLICATE, STALE, CONFLICT]",
      "EventId": "newtype alphalab.core.ids.EventId",
      "EventType": "enum alphalab.core.enums.EventType[SIGNAL, ORDER, FILL, TRADE, POSITION, PORTFOLIO]",
      "ExecutionEventKind": "enum alphalab.core.lifecycle.ExecutionEventKind[ORDER_ACCEPTED, ORDER_REJECTED, ORDER_PARTIALLY_FILLED, ORDER_FILLED, ORDER_CANCELLED, ORDER_EXPIRED, ORDER_REPLACED, ORDER_CANCEL_REJECTED, POSITION_CHANGED, BALANCE_CHANGED, BROKER_DISCONNECTED, BROKER_CONNECTED]",
      "ExecutionRequirements": "class alphalab.core.capabilities.ExecutionRequirements(asset_class: 'AssetType', listing_venue: 'str', account_id: 'str', order_types: 'frozenset[OrderType]', time_in_force: 'frozenset[TimeInForce]', short_selling: 'bool', fractional_quantities: 'bool', extended_hours: 'bool', bracket_orders: 'bool', margin: 'bool', features: 'frozenset[Capability]') -> None",
      "FILL_EVENT_KINDS": "value builtins.frozenset",
      "Fill": "class alphalab.core.fill.Fill(fill_id: alphalab.core.ids.FillId, order_id: alphalab.core.ids.OrderId, asset_id: alphalab.core.ids.AssetId, side: alphalab.core.enums.Side, quantity: decimal.Decimal, price: decimal.Decimal, filled_at: float, commission: decimal.Decimal = Decimal('0')) -> None",
      "FillId": "newtype alphalab.core.ids.FillId",
      "MARKET": "value alphalab.common.order_terms.OrderTerms",
      "MarketCapability": "class alphalab.core.capabilities.MarketCapability(asset_class: 'AssetType', listing_venue: 'str', order_types: 'frozenset[OrderType]', time_in_force: 'frozenset[TimeInForce]', short_selling: 'Support', fractional_quantities: 'Support', extended_hours: 'Support', bracket_orders: 'Support') -> None",
      "ORDER_EVENT_KINDS": "value builtins.frozenset",
      "ORDER_TRANSITIONS": "value builtins.mappingproxy",
      "ORDER_TYPE_CAPABILITIES": "value builtins.mappingproxy",
      "OrderId": "newtype alphalab.core.ids.OrderId",
      "OrderRequest": "class alphalab.core.order_request.OrderRequest(order_id: str, strategy_id: str, asset_id: str, side: alphalab.core.enums.Side, quantity: decimal.Decimal, price: decimal.Decimal, timestamp: float = 0.0, contributions: tuple[alphalab.core.contribution.StrategyContribution, ...] = <factory>, terms: alphalab.common.order_terms.OrderTerms = OrderTerms(order_type=<OrderType.MARKET: 'market'>, limit_price=None, stop_price=None, time_in_force=<TimeInForce.DAY: 'day'>, expire_at=None)) -> None",
      "OrderStatus": "enum alphalab.core.enums.OrderStatus[NEW, PENDING, ACCEPTED, PARTIALLY_FILLED, FILLED, CANCEL_PENDING, CANCELLED, REJECTED, EXPIRED]",
      "OrderTerms": "class alphalab.common.order_terms.OrderTerms(order_type: 'OrderType' = <OrderType.MARKET: 'market'>, limit_price: 'Decimal | None' = None, stop_price: 'Decimal | None' = None, time_in_force: 'TimeInForce' = <TimeInForce.DAY: 'day'>, expire_at: 'float | None' = None) -> None",
      "OrderType": "enum alphalab.common.order_terms.OrderType[MARKET, LIMIT, STOP, STOP_LIMIT]",
      "PortfolioId": "newtype alphalab.core.ids.PortfolioId",
      "PositionId": "newtype alphalab.core.ids.PositionId",
      "RequirementDimension": "enum alphalab.core.capabilities.RequirementDimension[MARKET, ORDER_TYPE, TIME_IN_FORCE, EXECUTION_FEATURE, ACCOUNT, RISK]",
      "STATUS_EVENT_KINDS": "value builtins.frozenset",
      "Side": "enum alphalab.core.enums.Side[BUY, SELL]",
      "SignalId": "newtype alphalab.core.ids.SignalId",
      "StrategyContribution": "class alphalab.core.contribution.StrategyContribution(strategy_id: str, quantity: decimal.Decimal) -> None",
      "StrategyId": "newtype alphalab.core.ids.StrategyId",
      "Support": "enum alphalab.core.capabilities.Support[SUPPORTED, UNSUPPORTED, UNDECLARED]",
      "TERMINAL_ORDER_STATUSES": "value builtins.frozenset",
      "TimeInForce": "enum alphalab.common.order_terms.TimeInForce[DAY, GTC, IOC, FOK, GTD, OPG, CLS]",
      "Trade": "class alphalab.core.trade.Trade(trade_id: alphalab.core.ids.TradeId, asset_id: alphalab.core.ids.AssetId, side: alphalab.core.enums.Side, quantity: decimal.Decimal, average_price: decimal.Decimal, fill_ids: tuple[alphalab.core.ids.FillId, ...], executed_at: float, order_id: alphalab.core.ids.OrderId | None = None) -> None",
      "TradeId": "newtype alphalab.core.ids.TradeId",
      "VENUE_FEATURES": "value builtins.frozenset",
      "WORKING_ORDER_STATUSES": "value builtins.frozenset",
      "check_compatibility": "function alphalab.core.capabilities.check_compatibility(requirements: 'ExecutionRequirements', declaration: 'CapabilityDeclaration') -> 'CompatibilityReport'",
      "classify_order_event": "function alphalab.core.lifecycle.classify_order_event(status: 'OrderStatus', event: 'ExecutionEventKind', filled_quantity: 'Decimal') -> 'tuple[EventClassification, OrderStatus]'",
      "contributions_from": "function alphalab.core.contribution.contributions_from(sized: collections.abc.Iterable[tuple[str, decimal.Decimal]]) -> tuple[alphalab.core.contribution.StrategyContribution, ...]",
      "is_terminal_status": "function alphalab.core.lifecycle.is_terminal_status(status: 'OrderStatus') -> 'bool'",
      "new_account_id": "function alphalab.core.ids.new_account_id() -> alphalab.core.ids.AccountId",
      "new_asset_id": "function alphalab.core.ids.new_asset_id() -> alphalab.core.ids.AssetId",
      "new_event_id": "function alphalab.core.ids.new_event_id() -> alphalab.core.ids.EventId",
      "new_fill_id": "function alphalab.core.ids.new_fill_id() -> alphalab.core.ids.FillId",
      "new_order_id": "function alphalab.core.ids.new_order_id() -> alphalab.core.ids.OrderId",
      "new_portfolio_id": "function alphalab.core.ids.new_portfolio_id() -> alphalab.core.ids.PortfolioId",
      "new_position_id": "function alphalab.core.ids.new_position_id() -> alphalab.core.ids.PositionId",
      "new_signal_id": "function alphalab.core.ids.new_signal_id() -> alphalab.core.ids.SignalId",
      "new_strategy_id": "function alphalab.core.ids.new_strategy_id() -> alphalab.core.ids.StrategyId",
      "new_trade_id": "function alphalab.core.ids.new_trade_id() -> alphalab.core.ids.TradeId",
      "new_uuid": "function alphalab.core.ids.new_uuid() -> str",
      "next_order_status": "function alphalab.core.lifecycle.next_order_status(status: 'OrderStatus', event: 'ExecutionEventKind', filled_quantity: 'Decimal') -> 'OrderStatus | None'",
      "order_requirements": "function alphalab.core.capabilities.order_requirements(*, asset_class: 'AssetType', listing_venue: 'str', account_id: 'str', order_type: 'OrderType', time_in_force: 'TimeInForce', side: 'Side', quantity: 'Decimal', position_before: 'Decimal', extended_hours: 'bool', bracket_orders: 'bool', margin: 'bool', features: 'frozenset[Capability]') -> 'ExecutionRequirements'",
      "reachable_statuses": "function alphalab.core.lifecycle.reachable_statuses(status: 'OrderStatus') -> 'frozenset[OrderStatus]'",
      "split_by_contribution": "function alphalab.core.contribution.split_by_contribution(amount: decimal.Decimal, contributions: collections.abc.Sequence[alphalab.core.contribution.StrategyContribution], quantum: decimal.Decimal) -> tuple[tuple[str, decimal.Decimal], ...]",
      "supports": "function alphalab.core.capabilities.supports(declaration: 'CapabilityDeclaration', capability: 'Capability', *, asset_class: 'AssetType | None' = None, listing_venue: 'str | None' = None, account_id: 'str | None' = None) -> 'Support'",
      "validate_uuid_id": "function alphalab.core.ids.validate_uuid_id(value: str, field_name: str) -> None",
      "working_status_for": "function alphalab.core.lifecycle.working_status_for(filled_quantity: 'Decimal') -> 'OrderStatus'"
    },
    "alphalab.crypto": {
      "BASIS_POINT": "value decimal.Decimal",
      "CoverageReport": "class alphalab.crypto.availability.CoverageReport(start: 'float', end: 'float', expected_interval_seconds: 'float', expected: 'int', observed: 'int', gaps: 'tuple[ObservationGap, ...]', coverage: 'float | None') -> None",
      "CryptoComputationError": "class alphalab.crypto.exceptions.CryptoComputationError",
      "CryptoError": "class alphalab.crypto.exceptions.CryptoError",
      "CryptoInputError": "class alphalab.crypto.exceptions.CryptoInputError",
      "CryptoInstrument": "class alphalab.crypto.instrument.CryptoInstrument(base_asset: str, quote_asset: str, instrument_type: alphalab.crypto.enums.InstrumentType, exchange: str, contract_size: decimal.Decimal, expiry: float | None = None) -> None",
      "FeeSchedule": "class alphalab.crypto.venue.FeeSchedule(maker_bps: 'Decimal', taker_bps: 'Decimal') -> None",
      "FundingAccrual": "class alphalab.crypto.funding.FundingAccrual(timestamp: float, rate: decimal.Decimal, mark_price: decimal.Decimal, notional: decimal.Decimal, payment: decimal.Decimal) -> None",
      "FundingRate": "class alphalab.crypto.funding.FundingRate(instrument_symbol: str, rate: decimal.Decimal, timestamp: float, interval_hours: int) -> None",
      "FundingRateHistory": "class alphalab.crypto.funding.FundingRateHistory(instrument_symbol: str, rates: tuple[alphalab.crypto.funding.FundingRate, ...]) -> None",
      "FundingSummary": "class alphalab.crypto.funding.FundingSummary(instrument_symbol: str, accruals: tuple[alphalab.crypto.funding.FundingAccrual, ...], total: decimal.Decimal, intervals: int) -> None",
      "InstrumentType": "enum alphalab.crypto.enums.InstrumentType[SPOT, FUTURE, PERPETUAL]",
      "LiquidityRole": "enum alphalab.crypto.venue.LiquidityRole[MAKER, TAKER]",
      "MaintenanceBasis": "enum alphalab.crypto.perpetual.MaintenanceBasis[ENTRY_NOTIONAL, MARK_NOTIONAL]",
      "ObservationGap": "class alphalab.crypto.availability.ObservationGap(after: 'float', before: 'float', seconds: 'float', missing: 'int') -> None",
      "PriceSource": "enum alphalab.crypto.venue.PriceSource[INDEX, MARK, LAST_TRADE]",
      "VenueDispersion": "class alphalab.crypto.venue.VenueDispersion(prices: 'Mapping[str, Decimal]', lowest_venue: 'str', highest_venue: 'str', lowest: 'Decimal', highest: 'Decimal', spread: 'Decimal', relative_spread: 'Decimal') -> None",
      "VenueSpecification": "class alphalab.crypto.venue.VenueSpecification(venue: 'str', funding_interval_hours: 'int', fees: 'FeeSchedule', price_source: 'PriceSource', minimum_notional: 'Decimal', settlement_asset: 'str') -> None",
      "accrued_funding": "function alphalab.crypto.funding.accrued_funding(history: alphalab.crypto.funding.FundingRateHistory, position_quantity: decimal.Decimal, marks: collections.abc.Mapping[float, decimal.Decimal], contract_size: decimal.Decimal) -> alphalab.crypto.funding.FundingSummary",
      "annualized_funding_rate": "function alphalab.crypto.funding.annualized_funding_rate(history: alphalab.crypto.funding.FundingRateHistory) -> decimal.Decimal",
      "average_funding_rate": "function alphalab.crypto.funding.average_funding_rate(history: alphalab.crypto.funding.FundingRateHistory) -> decimal.Decimal",
      "compute_funding_payment": "function alphalab.crypto.funding.compute_funding_payment(position_quantity: decimal.Decimal, mark_price: decimal.Decimal, funding_rate: decimal.Decimal, contract_size: decimal.Decimal) -> decimal.Decimal",
      "compute_liquidation_price": "function alphalab.crypto.perpetual.compute_liquidation_price(entry_price: decimal.Decimal, side: alphalab.portfolio.types.PositionSide, leverage: decimal.Decimal, maintenance_margin_rate: decimal.Decimal, *, basis: alphalab.crypto.perpetual.MaintenanceBasis, quantity: decimal.Decimal, fees: decimal.Decimal, funding: decimal.Decimal) -> decimal.Decimal | None",
      "coverage": "function alphalab.crypto.availability.coverage(timestamps: 'Sequence[float]', start: 'float', end: 'float', expected_interval_seconds: 'float') -> 'CoverageReport'",
      "cross_venue_dispersion": "function alphalab.crypto.venue.cross_venue_dispersion(prices: 'Mapping[str, Decimal]') -> 'VenueDispersion'",
      "crypto_symbol": "function alphalab.crypto.instrument.crypto_symbol(instrument: alphalab.crypto.instrument.CryptoInstrument) -> str",
      "funding_instants": "function alphalab.crypto.funding.funding_instants(start: float, end: float, interval_hours: int, anchor: float) -> tuple[float, ...]",
      "mark_to_market": "function alphalab.crypto.perpetual.mark_to_market(position: alphalab.portfolio.position.Position, mark_price: decimal.Decimal, timestamp: float) -> tuple[alphalab.portfolio.position.Position, decimal.Decimal]",
      "observation_gaps": "function alphalab.crypto.availability.observation_gaps(timestamps: 'Sequence[float]', expected_interval_seconds: 'float') -> 'tuple[ObservationGap, ...]'",
      "open_crypto_position": "function alphalab.crypto.instrument.open_crypto_position(instrument: alphalab.crypto.instrument.CryptoInstrument, quantity: decimal.Decimal, price: decimal.Decimal, timestamp: float, *, minor_units: int | None = None) -> alphalab.portfolio.position.Position",
      "to_canonical_symbol": "function alphalab.crypto.symbol_normalization.to_canonical_symbol(base_asset: str, quote_asset: str) -> str",
      "trading_fee": "function alphalab.crypto.venue.trading_fee(specification: 'VenueSpecification', notional: 'Decimal', role: 'LiquidityRole') -> 'Decimal'"
    },
    "alphalab.data": {
      "AdjustmentOutcome": "class alphalab.data.corporate_actions.AdjustmentOutcome(bars: 'tuple[Bar, ...]', basis: 'PriceBasis', adjustments: 'tuple[AdjustmentRecord, ...]') -> None",
      "AdjustmentRecord": "class alphalab.data.corporate_actions.AdjustmentRecord(action: 'str', symbol: 'str', effective_timestamp: 'float', factor: 'float', bars_affected: 'int', detail: 'str') -> None",
      "AlternativeDataRecord": "class alphalab.data.feed.AlternativeDataRecord(symbol: str, timestamp: float, source: str, sentiment_score: float) -> None",
      "AmbiguousField": "class alphalab.data.schema.AmbiguousField(role: 'FieldRole', columns: 'tuple[str, ...]', reason: 'str') -> None",
      "Bar": "class alphalab.data.feed.Bar(symbol: str, timestamp: float, open: float, high: float, low: float, close: float, volume: float) -> None",
      "BarStamp": "enum alphalab.data.time.BarStamp[INTERVAL_START, INTERVAL_END]",
      "COLUMN_ALIASES": "value builtins.dict",
      "CONTENT_DIGEST_SCHEME": "value builtins.str",
      "CONTINUOUS_SESSION": "value alphalab.data.calendar.SessionWindow",
      "CanonicalRecord": "class alphalab.data.feed.CanonicalRecord(symbol: str, timestamp: float) -> None",
      "CatalogRecord": "class alphalab.data.catalog.CatalogRecord(metadata: alphalab.data.metadata.DatasetMetadata, quality: alphalab.data.quality.QualityReport, record_count: int) -> None",
      "CleaningOutcome": "class alphalab.data.cleaning.CleaningOutcome(records: 'tuple[CanonicalRecord, ...]', transformations: 'tuple[TransformationRecord, ...]') -> None",
      "CleaningPolicy": "class alphalab.data.cleaning.CleaningPolicy(duplicates: 'DuplicatePolicy', ordering: 'OrderingPolicy', invalid_records: 'InvalidRecordPolicy', missing_values: 'MissingValuePolicy') -> None",
      "CommoditySpec": "class alphalab.data.assets.CommoditySpec(symbol: 'str', currency: 'str', unit: 'str', delivery_location: 'str') -> None",
      "CorporateAction": "class alphalab.data.feed.CorporateAction(symbol: str, timestamp: float, action_type: str, details: str) -> None",
      "CryptoSpec": "class alphalab.data.assets.CryptoSpec(symbol: 'str', venue: 'str', base_asset: 'str', quote_asset: 'str') -> None",
      "CsvDialect": "class alphalab.data.csv_source.CsvDialect(delimiter: 'str', quote_char: 'str' = '\"', has_header: 'bool' = True) -> None",
      "DATASET_KEY_SCHEME": "value builtins.str",
      "DELIMITER_CANDIDATES": "value builtins.tuple",
      "DataAdapter": "class alphalab.data.adapter.DataAdapter()",
      "DataAssetClass": "enum alphalab.data.symbols.DataAssetClass[EQUITY, ETF, FUTURE, OPTION, FOREX, CRYPTO, FUNDAMENTAL, ECONOMIC, ALTERNATIVE, INDEX, RATE, COMMODITY]",
      "DataEvent": "class alphalab.data.events.DataEvent(event_id: str, timestamp: float) -> None",
      "DataExtractorProtocol": "class alphalab.data.protocol.DataExtractorProtocol(*args, **kwargs)",
      "DataManager": "class alphalab.data.manager.DataManager()",
      "DataQualityError": "class alphalab.data.exceptions.DataQualityError",
      "DataQualityReport": "class alphalab.data.quality.DataQualityReport(dataset_id: 'str', row_count: 'int', valid_rows: 'int', rejected_rows: 'tuple[RowRejection, ...]' = (), duplicate_count: 'int' = 0, missing_count: 'int' = 0, invalid_count: 'int' = 0, out_of_order_count: 'int' = 0, warnings: 'tuple[ValidationFinding, ...]' = (), errors: 'tuple[ValidationFinding, ...]' = <factory>) -> None",
      "DataValidationError": "class alphalab.data.exceptions.DataValidationError",
      "Dataset": "class alphalab.data.dataset.Dataset(metadata: 'DatasetMetadata', schema: 'DatasetSchema', quality: 'QualityReport', records: 'tuple[CanonicalRecord, ...]' = <factory>, provenance: 'DatasetProvenance | None' = None, quality_detail: 'DataQualityReport | None' = None) -> None",
      "DatasetCataloged": "class alphalab.data.events.DatasetCataloged(event_id: str, timestamp: float, dataset_id: str, asset_class: str) -> None",
      "DatasetCleaned": "class alphalab.data.events.DatasetCleaned(event_id: str, timestamp: float, dataset_id: str, records_removed: int, derived_dataset_id: str = '') -> None",
      "DatasetIngested": "class alphalab.data.events.DatasetIngested(event_id: str, timestamp: float, dataset_id: str, record_count: int) -> None",
      "DatasetMetadata": "class alphalab.data.metadata.DatasetMetadata(dataset_id: str, source_name: str, asset_class: alphalab.data.symbols.DataAssetClass, frequency: alphalab.data.time.TimeFrequency, start_timestamp: float, end_timestamp: float, timezone: str = 'UTC', metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "DatasetProvenance": "class alphalab.data.provenance.DatasetProvenance(source: 'RawSource', schema: 'DatasetSchema', timezone_name: 'str', frequency: 'TimeFrequency', price_basis: 'PriceBasis', cleaning_policy: 'CleaningPolicy', engine_version: 'str', dataset_version: 'str', calendar_id: 'str | None' = None, transformations: 'tuple[TransformationRecord, ...]' = (), adjustments: 'tuple[AdjustmentRecord, ...]' = (), instrument: 'InstrumentSpec | None' = None) -> None",
      "DatasetRegistry": "class alphalab.data.registry.DatasetRegistry()",
      "DatasetResampled": "class alphalab.data.events.DatasetResampled(event_id: str, timestamp: float, dataset_id: str, derived_dataset_id: str, interval_seconds: float, record_count: int) -> None",
      "DatasetSchema": "class alphalab.data.schema.DatasetSchema(fields: 'tuple[str, ...]', data_type: 'str', bindings: 'Mapping[str, str]' = <factory>, timestamp_format: 'str | None' = None, timezone: 'str | None' = None, source_columns: 'tuple[str, ...]' = (), aggressor_codes: 'Mapping[str, str]' = <factory>) -> None",
      "DateOnlyPolicy": "enum alphalab.data.time.DateOnlyPolicy[START_OF_DAY, END_OF_DAY]",
      "Delisting": "class alphalab.data.corporate_actions.Delisting(symbol: 'str', effective_timestamp: 'float', reason: 'str') -> None",
      "Dividend": "class alphalab.data.feed.Dividend(symbol: str, timestamp: float, amount: float, currency: str) -> None",
      "DuplicatePolicy": "enum alphalab.data.cleaning.DuplicatePolicy[REFUSE, KEEP_FIRST, KEEP_LAST]",
      "EconomicEvent": "class alphalab.data.feed.EconomicEvent(symbol: str, timestamp: float, event_name: str, actual: float, forecast: float, previous: float) -> None",
      "EquitySpec": "class alphalab.data.assets.EquitySpec(symbol: 'str', currency: 'str', exchange: 'str', is_fund: 'bool' = False) -> None",
      "FieldBinding": "class alphalab.data.schema.FieldBinding(role: 'FieldRole', column: 'str', rationale: 'str') -> None",
      "FieldRole": "enum alphalab.data.schema.FieldRole[TIMESTAMP, SYMBOL, OPEN, HIGH, LOW, CLOSE, VOLUME, TRADE_COUNT, BID, ASK, BID_SIZE, ASK_SIZE, PRICE, SIZE, TRADE_ID, AGGRESSOR]",
      "FindingKind": "enum alphalab.data.validation.FindingKind[MISSING_VALUE, NON_NUMERIC, NON_FINITE, UNPARSEABLE_TIMESTAMP, MALFORMED_ROW, EMPTY_SYMBOL, DUPLICATE_TIMESTAMP, OUT_OF_ORDER, INVALID_OHLC, NON_POSITIVE_PRICE, NEGATIVE_VOLUME, CROSSED_QUOTE, INCONSISTENT_FREQUENCY, INCONSISTENT_RECORD, NON_POSITIVE_SIZE, DUPLICATE_TRADE_ID, INDISTINGUISHABLE_PRINTS, UNKNOWN_CODE]",
      "FundamentalRecord": "class alphalab.data.feed.FundamentalRecord(symbol: str, timestamp: float, metric_name: str, metric_value: float) -> None",
      "FutureSpec": "class alphalab.data.assets.FutureSpec(symbol: 'str', currency: 'str', exchange: 'str', root: 'str', expiry: 'float', multiplier: 'float', tick_size: 'float', contract_month: 'float | None' = None) -> None",
      "FxSpec": "class alphalab.data.assets.FxSpec(symbol: 'str', base_currency: 'str', quote_currency: 'str') -> None",
      "IndexSpec": "class alphalab.data.assets.IndexSpec(symbol: 'str', currency: 'str', publisher: 'str') -> None",
      "IngestionRequest": "class alphalab.data.ingestion.IngestionRequest(name: 'str', source: 'RawSource', frequency: 'TimeFrequency', asset_class: 'DataAssetClass', cleaning_policy: 'CleaningPolicy', price_basis: 'PriceBasis', timezone_name: 'str | None' = None, date_policy: 'DateOnlyPolicy | None' = None, bar_stamp: 'BarStamp | None' = None, symbol: 'str | None' = None, calendar: 'MarketCalendar | None' = None, instrument: 'InstrumentSpec | None' = None, declared_record_type: 'RecordType | None' = None, splits: 'tuple[Split, ...]' = (), dividends: 'tuple[Dividend, ...]' = (), target_basis: 'PriceBasis | None' = None, trade_columns: 'TradeColumns | None' = None) -> None",
      "IngestionResult": "class alphalab.data.ingestion.IngestionResult(dataset: 'Dataset', detection: 'SchemaDetection', quality: 'DataQualityReport', transformations: 'tuple[TransformationRecord, ...]', adjustments: 'tuple[AdjustmentRecord, ...]', assumptions: 'tuple[str, ...]') -> None",
      "InstrumentLifecycleEvent": "alias InstrumentLifecycleEvent",
      "InstrumentSpec": "alias InstrumentSpec",
      "InvalidDataStateError": "class alphalab.data.exceptions.InvalidDataStateError",
      "InvalidRecordPolicy": "enum alphalab.data.cleaning.InvalidRecordPolicy[REFUSE, DROP, KEEP]",
      "MalformedRow": "class alphalab.data.csv_source.MalformedRow(line_number: 'int', values: 'tuple[str, ...]', reason: 'str') -> None",
      "MarketCalendar": "class alphalab.data.calendar.MarketCalendar(calendar_id: 'str', timezone_name: 'str', weekly_sessions: 'Mapping[int, tuple[SessionWindow, ...]]', holidays: 'frozenset[date]' = frozenset(), special_sessions: 'Mapping[date, tuple[SessionWindow, ...]]' = <factory>) -> None",
      "Merger": "class alphalab.data.corporate_actions.Merger(target_symbol: 'str', acquirer_symbol: 'str', share_ratio: 'float', cash_per_share: 'float', effective_timestamp: 'float') -> None",
      "MissingValuePolicy": "enum alphalab.data.cleaning.MissingValuePolicy[REFUSE, DROP_ROW]",
      "OptionSpec": "class alphalab.data.assets.OptionSpec(symbol: 'str', currency: 'str', exchange: 'str', underlying_symbol: 'str', strike: 'float', expiry: 'float', option_type: 'OptionType', multiplier: 'float', style: 'ExerciseStyle') -> None",
      "OrderBook": "class alphalab.data.feed.OrderBook(symbol: str, timestamp: float, bids: tuple[alphalab.data.feed.OrderBookLevel, ...] = <factory>, asks: tuple[alphalab.data.feed.OrderBookLevel, ...] = <factory>) -> None",
      "OrderBookLevel": "class alphalab.data.feed.OrderBookLevel(price: float, size: float) -> None",
      "OrderingPolicy": "enum alphalab.data.cleaning.OrderingPolicy[REFUSE, SORT]",
      "PriceBasis": "enum alphalab.data.corporate_actions.PriceBasis[RAW, SPLIT_ADJUSTED, TOTAL_RETURN]",
      "QualityReport": "class alphalab.data.quality.QualityReport(dataset_id: 'str', completeness: 'float', consistency: 'float', missing_count: 'int', duplicate_count: 'int', invalid_count: 'int', out_of_order_count: 'int', quality_score: 'float') -> None",
      "QualityReportGenerated": "class alphalab.data.events.QualityReportGenerated(event_id: str, timestamp: float, dataset_id: str, quality_score: float) -> None",
      "Quote": "class alphalab.data.feed.Quote(symbol: str, timestamp: float, bid: float, ask: float, bid_size: float, ask_size: float) -> None",
      "REFUSE_EVERYTHING": "value alphalab.data.cleaning.CleaningPolicy",
      "RateSpec": "class alphalab.data.assets.RateSpec(symbol: 'str', currency: 'str', tenor_days: 'int', day_count: 'str', quoted_in_percent: 'bool') -> None",
      "RawRow": "class alphalab.data.csv_source.RawRow(line_number: 'int', values: 'tuple[str, ...]') -> None",
      "RawSource": "class alphalab.data.source.RawSource(kind: 'SourceKind', location: 'str', retrieved_at: 'float', content_hash: 'str', byte_count: 'int', media_type: 'str', encoding: 'str | None' = None, attributes: 'MetadataMapping' = <factory>) -> None",
      "RawTable": "class alphalab.data.csv_source.RawTable(columns: 'tuple[str, ...]', rows: 'tuple[RawRow, ...]', malformed: 'tuple[MalformedRow, ...]', dialect: 'CsvDialect') -> None",
      "RecordType": "enum alphalab.data.schema.RecordType[BAR, QUOTE, TRADE]",
      "RowRejection": "class alphalab.data.validation.RowRejection(line_number: 'int', values: 'tuple[str, ...]', findings: 'tuple[ValidationFinding, ...]') -> None",
      "SchemaDetection": "class alphalab.data.schema.SchemaDetection(bindings: 'tuple[FieldBinding, ...]', ambiguous: 'tuple[AmbiguousField, ...]', unresolved: 'tuple[FieldRole, ...]', unmapped_columns: 'tuple[str, ...]', record_type: 'RecordType | None', record_type_rationale: 'str', timestamp_format: 'TimestampFormat | None', timestamp_rationale: 'str', assumptions: 'tuple[str, ...]' = (), aggressor_codes: 'Mapping[str, TradeAggressor]' = <factory>) -> None",
      "SessionWindow": "class alphalab.data.calendar.SessionWindow(opens: 'time', closes: 'time') -> None",
      "Severity": "enum alphalab.data.validation.Severity[WARNING, ERROR]",
      "SourceKind": "enum alphalab.data.source.SourceKind[LOCAL_FILE, UPLOADED_FILE, HTTP_RESPONSE, OBJECT_STORAGE, BROKER_EXPORT, VENDOR_FILE, IN_MEMORY]",
      "Split": "class alphalab.data.feed.Split(symbol: str, timestamp: float, ratio: float) -> None",
      "SymbolChange": "class alphalab.data.corporate_actions.SymbolChange(old_symbol: 'str', new_symbol: 'str', effective_timestamp: 'float') -> None",
      "TimeFrequency": "enum alphalab.data.time.TimeFrequency[TICK, SECOND, MINUTE, HOURLY, DAILY, WEEKLY, MONTHLY, CUSTOM]",
      "TimestampFormat": "enum alphalab.data.time.TimestampFormat[EPOCH_SECONDS, EPOCH_MILLISECONDS, ISO_8601_AWARE, ISO_8601_NAIVE, DATE_ONLY]",
      "Trade": "class alphalab.data.feed.Trade(symbol: str, timestamp: float, price: float, size: float, trade_id: str = '', aggressor: alphalab.data.feed.TradeAggressor | None = None) -> None",
      "TradeAggressor": "enum alphalab.data.feed.TradeAggressor[BUYER, SELLER]",
      "TradeColumns": "class alphalab.data.schema.TradeColumns(timestamp: 'str', price: 'str', size: 'str', symbol: 'str | None' = None, trade_id: 'str | None' = None, aggressor: 'str | None' = None, aggressor_codes: 'Mapping[str, TradeAggressor]' = <factory>) -> None",
      "TransformationRecord": "class alphalab.data.cleaning.TransformationRecord(operation: 'str', rows_affected: 'int', reason: 'str') -> None",
      "UniversalDataEngine": "class alphalab.data.engine.UniversalDataEngine()",
      "UniversalDataError": "class alphalab.data.exceptions.UniversalDataError",
      "UniversalDataState": "class alphalab.data.state.UniversalDataState(engine_id: str, datasets: alphalab.common.persistent_map.PersistentMap[str, alphalab.data.dataset.Dataset] = <factory>, catalog: alphalab.common.persistent_map.PersistentMap[str, alphalab.data.catalog.CatalogRecord] = <factory>, quality_reports: alphalab.common.persistent_map.PersistentMap[str, alphalab.data.quality.QualityReport] = <factory>, schemas: alphalab.common.persistent_map.PersistentMap[str, alphalab.data.schema.DatasetSchema] = <factory>, metadata: alphalab.common.persistent_map.PersistentMap[str, alphalab.data.metadata.DatasetMetadata] = <factory>, lineage: alphalab.common.persistent_map.PersistentMap[str, str] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.data.events.DataEvent] = <factory>) -> None",
      "ValidationFinding": "class alphalab.data.validation.ValidationFinding(kind: 'FindingKind', severity: 'Severity', line_number: 'int | None', column: 'str | None', detail: 'str') -> None",
      "apply_adjustments": "function alphalab.data.corporate_actions.apply_adjustments(bars: 'Sequence[Bar]', splits: 'Sequence[Split]', dividends: 'Sequence[Dividend]', basis: 'PriceBasis') -> 'AdjustmentOutcome'",
      "asset_class_of": "function alphalab.data.assets.asset_class_of(spec: 'InstrumentSpec') -> 'DataAssetClass'",
      "canonical_dataset_key": "function alphalab.data.provenance.canonical_dataset_key(name: 'str', content_hash: 'str', schema: 'DatasetSchema', timezone_name: 'str', calendar_id: 'str | None', frequency: 'TimeFrequency', price_basis: 'PriceBasis', cleaning_policy: 'CleaningPolicy', transformations: 'Sequence[TransformationRecord]', adjustments: 'Sequence[AdjustmentRecord]') -> 'str'",
      "canonical_field": "function alphalab.data.formats.canonical_field(column: str) -> str",
      "catalog_summary": "function alphalab.data.views.catalog_summary(state: alphalab.data.state.UniversalDataState) -> collections.abc.Sequence[alphalab.data.catalog.CatalogRecord]",
      "clean_records": "function alphalab.data.cleaning.clean_records(records: 'Sequence[CanonicalRecord]', policy: 'CleaningPolicy', findings: 'Sequence[ValidationFinding]') -> 'CleaningOutcome'",
      "coerce_row": "function alphalab.data.validation.coerce_row(table: 'RawTable', row: 'RawRow', detection: 'SchemaDetection', timezone_name: 'str | None', date_policy: 'DateOnlyPolicy | None', default_symbol: 'str | None') -> 'tuple[CanonicalRecord | None, tuple[ValidationFinding, ...]]'",
      "content_digest": "function alphalab.data.source.content_digest(payload: 'bytes') -> 'str'",
      "create_dataset": "function alphalab.data.loader.create_dataset(metadata: alphalab.data.metadata.DatasetMetadata, bars: tuple[alphalab.data.feed.Bar, ...]) -> alphalab.data.dataset.Dataset",
      "dataset_lineage": "function alphalab.data.views.dataset_lineage(state: alphalab.data.state.UniversalDataState, dataset_id: str) -> tuple[str, ...]",
      "dataset_provenance": "function alphalab.data.views.dataset_provenance(state: alphalab.data.state.UniversalDataState, dataset_id: str) -> alphalab.data.provenance.DatasetProvenance | None",
      "dataset_summary": "function alphalab.data.views.dataset_summary(state: alphalab.data.state.UniversalDataState) -> collections.abc.Sequence[alphalab.data.dataset.Dataset]",
      "declare_trade_schema": "function alphalab.data.schema.declare_trade_schema(table: 'RawTable', columns: 'TradeColumns') -> 'SchemaDetection'",
      "decode_text": "function alphalab.data.csv_source.decode_text(payload: 'bytes', encoding: 'str') -> 'str'",
      "derive_dataset_version": "function alphalab.data.provenance.derive_dataset_version(name: 'str', content_hash: 'str', schema: 'DatasetSchema', timezone_name: 'str', calendar_id: 'str | None', frequency: 'TimeFrequency', price_basis: 'PriceBasis', cleaning_policy: 'CleaningPolicy', transformations: 'Sequence[TransformationRecord]', adjustments: 'Sequence[AdjustmentRecord]') -> 'str'",
      "derive_transformed_version": "function alphalab.data.provenance.derive_transformed_version(parent_version: 'str', transformations: 'Sequence[TransformationRecord]') -> 'str'",
      "detect_delimiter": "function alphalab.data.csv_source.detect_delimiter(text: 'str') -> 'tuple[str | None, str]'",
      "detect_schema": "function alphalab.data.schema.detect_schema(table: 'RawTable', declared_record_type: 'RecordType | None' = None) -> 'SchemaDetection'",
      "detect_timestamp_format": "function alphalab.data.time.detect_timestamp_format(values: 'Sequence[str]') -> 'tuple[TimestampFormat | None, str]'",
      "duplicate_key": "function alphalab.data.validation.duplicate_key(record: 'CanonicalRecord') -> 'tuple[object, ...] | None'",
      "evaluate_bar_quality": "function alphalab.data.quality.evaluate_bar_quality(dataset_id: 'str', bars: 'tuple[Bar, ...]') -> 'QualityReport'",
      "evaluate_quality": "function alphalab.data.quality.evaluate_quality(dataset_id: 'str', records: 'Sequence[CanonicalRecord]', row_count: 'int', rejected: 'Sequence[RowRejection]', findings: 'Sequence[ValidationFinding]') -> 'DataQualityReport'",
      "frequency_seconds": "function alphalab.data.time.frequency_seconds(frequency: 'TimeFrequency') -> 'float | None'",
      "infer_frequency": "function alphalab.data.time.infer_frequency(timestamps: 'Sequence[float]') -> 'tuple[TimeFrequency | None, str]'",
      "ingest_table": "function alphalab.data.ingestion.ingest_table(table: 'RawTable', request: 'IngestionRequest', *, content_hash: 'str | None' = None) -> 'IngestionResult'",
      "is_internally_consistent": "function alphalab.data.cleaning.is_internally_consistent(record: 'CanonicalRecord') -> 'bool'",
      "metadata_view": "function alphalab.data.views.metadata_view(state: alphalab.data.state.UniversalDataState, dataset_id: str) -> alphalab.data.metadata.DatasetMetadata | None",
      "normalize_prices": "function alphalab.data.normalization.normalize_prices(bars: tuple[alphalab.data.feed.Bar, ...], factor: float) -> tuple[alphalab.data.feed.Bar, ...]",
      "parse_and_load": "function alphalab.data.ingestion.parse_and_load(metadata: 'DatasetMetadata', raw_rows: 'Sequence[Mapping[str, Any]]') -> 'Dataset'",
      "parse_raw_rows": "function alphalab.data.parser.parse_raw_rows(symbol: str, raw_rows: collections.abc.Sequence[collections.abc.Mapping[str, Any]]) -> tuple[alphalab.data.feed.Bar, ...]",
      "parse_timestamp": "function alphalab.data.time.parse_timestamp(value: 'str', timestamp_format: 'TimestampFormat', timezone_name: 'str | None', date_policy: 'DateOnlyPolicy | None') -> 'float'",
      "quality_report": "function alphalab.data.views.quality_report(state: alphalab.data.state.UniversalDataState, dataset_id: str) -> alphalab.data.quality.QualityReport | None",
      "raw_source_from_bytes": "function alphalab.data.source.raw_source_from_bytes(kind: 'SourceKind', location: 'str', payload: 'bytes', retrieved_at: 'float', media_type: 'str', encoding: 'str | None' = None, attributes: 'MetadataMapping | None' = None) -> 'RawSource'",
      "raw_source_from_path": "function alphalab.data.source.raw_source_from_path(path: 'str | Path', retrieved_at: 'float', media_type: 'str', encoding: 'str' = 'utf-8') -> 'tuple[RawSource, bytes]'",
      "read_delimited": "function alphalab.data.csv_source.read_delimited(text: 'str', dialect: 'CsvDialect | None') -> 'RawTable'",
      "remove_duplicates": "function alphalab.data.cleaning.remove_duplicates(bars: 'tuple[Bar, ...]') -> 'tuple[Bar, ...]'",
      "remove_invalid_ohlc": "function alphalab.data.cleaning.remove_invalid_ohlc(bars: 'tuple[Bar, ...]') -> 'tuple[Bar, ...]'",
      "resample_bars": "function alphalab.data.conversion.resample_bars(bars: tuple[alphalab.data.feed.Bar, ...], interval_seconds: float) -> tuple[alphalab.data.feed.Bar, ...]",
      "resolve_zone": "function alphalab.data.time.resolve_zone(timezone_name: 'str') -> 'ZoneInfo'",
      "schema_report": "function alphalab.data.views.schema_report(state: alphalab.data.state.UniversalDataState, dataset_id: str) -> alphalab.data.schema.DatasetSchema | None",
      "validate_dataset_ingestion": "function alphalab.data.manager.validate_dataset_ingestion(state: alphalab.data.state.UniversalDataState, dataset: alphalab.data.dataset.Dataset) -> None",
      "validate_records": "function alphalab.data.validation.validate_records(records: 'Sequence[CanonicalRecord]', expected_frequency: 'TimeFrequency | None') -> 'tuple[ValidationFinding, ...]'"
    },
    "alphalab.deep_learning": {
      "ActivationType": "enum alphalab.deep_learning.activations.ActivationType[LINEAR, RELU, SIGMOID, TANH]",
      "AttentionGradients": "class alphalab.deep_learning.attention.AttentionGradients(queries: tuple[tuple[float, ...], ...], keys: tuple[tuple[float, ...], ...], values: tuple[tuple[float, ...], ...]) -> None",
      "AttentionOutput": "class alphalab.deep_learning.attention.AttentionOutput(context: tuple[tuple[float, ...], ...], weights: tuple[tuple[float, ...], ...]) -> None",
      "Conv1DForwardCache": "class alphalab.deep_learning.conv1d.Conv1DForwardCache(input: tuple[float, ...], pre_activation: tuple[float, ...], output: tuple[float, ...]) -> None",
      "Conv1DGradients": "class alphalab.deep_learning.conv1d.Conv1DGradients(kernel_gradients: tuple[float, ...], bias_gradient: float, input_gradients: tuple[float, ...]) -> None",
      "Conv1DLayer": "class alphalab.deep_learning.conv1d.Conv1DLayer(kernel: tuple[float, ...], bias: float, activation: alphalab.deep_learning.activations.ActivationType) -> None",
      "DLComputationError": "class alphalab.deep_learning.exceptions.DLComputationError",
      "DLInputError": "class alphalab.deep_learning.exceptions.DLInputError",
      "DeepLearningError": "class alphalab.deep_learning.exceptions.DeepLearningError",
      "DenseForwardCache": "class alphalab.deep_learning.dense.DenseForwardCache(input: tuple[float, ...], pre_activation: tuple[float, ...], output: tuple[float, ...]) -> None",
      "DenseGradients": "class alphalab.deep_learning.dense.DenseGradients(weight_gradients: tuple[tuple[float, ...], ...], bias_gradients: tuple[float, ...], input_gradients: tuple[float, ...]) -> None",
      "DenseLayer": "class alphalab.deep_learning.dense.DenseLayer(weights: tuple[tuple[float, ...], ...], bias: tuple[float, ...], activation: alphalab.deep_learning.activations.ActivationType) -> None",
      "LSTMCell": "class alphalab.deep_learning.lstm.LSTMCell(forget_gate: alphalab.deep_learning.dense.DenseLayer, input_gate: alphalab.deep_learning.dense.DenseLayer, candidate_gate: alphalab.deep_learning.dense.DenseLayer, output_gate: alphalab.deep_learning.dense.DenseLayer, hidden_size: int) -> None",
      "LSTMGradients": "class alphalab.deep_learning.lstm.LSTMGradients(forget_gate: alphalab.deep_learning.dense.DenseGradients, input_gate: alphalab.deep_learning.dense.DenseGradients, candidate_gate: alphalab.deep_learning.dense.DenseGradients, output_gate: alphalab.deep_learning.dense.DenseGradients, input_gradients: tuple[tuple[float, ...], ...], initial_hidden: tuple[float, ...], initial_cell: tuple[float, ...]) -> None",
      "LSTMRegressor": "class alphalab.deep_learning.lstm.LSTMRegressor(cell: alphalab.deep_learning.lstm.LSTMCell, head: alphalab.deep_learning.dense.DenseLayer) -> None",
      "LSTMState": "class alphalab.deep_learning.lstm.LSTMState(hidden: tuple[float, ...], cell: tuple[float, ...]) -> None",
      "LSTMStepCache": "class alphalab.deep_learning.lstm.LSTMStepCache(previous: alphalab.deep_learning.lstm.LSTMState, forget: alphalab.deep_learning.dense.DenseForwardCache, input: alphalab.deep_learning.dense.DenseForwardCache, candidate: alphalab.deep_learning.dense.DenseForwardCache, output: alphalab.deep_learning.dense.DenseForwardCache, state: alphalab.deep_learning.lstm.LSTMState, cell_tanh: tuple[float, ...]) -> None",
      "SelfAttentionCache": "class alphalab.deep_learning.attention.SelfAttentionCache(query: tuple[alphalab.deep_learning.dense.DenseForwardCache, ...], key: tuple[alphalab.deep_learning.dense.DenseForwardCache, ...], value: tuple[alphalab.deep_learning.dense.DenseForwardCache, ...], attention: alphalab.deep_learning.attention.AttentionOutput) -> None",
      "SelfAttentionGradients": "class alphalab.deep_learning.attention.SelfAttentionGradients(query: alphalab.deep_learning.dense.DenseGradients, key: alphalab.deep_learning.dense.DenseGradients, value: alphalab.deep_learning.dense.DenseGradients, input_gradients: tuple[tuple[float, ...], ...]) -> None",
      "SelfAttentionLayer": "class alphalab.deep_learning.attention.SelfAttentionLayer(query: alphalab.deep_learning.dense.DenseLayer, key: alphalab.deep_learning.dense.DenseLayer, value: alphalab.deep_learning.dense.DenseLayer) -> None",
      "Sequential": "class alphalab.deep_learning.network.Sequential(layers: tuple[alphalab.deep_learning.dense.DenseLayer, ...]) -> None",
      "activation_derivative": "function alphalab.deep_learning.activations.activation_derivative(activation: alphalab.deep_learning.activations.ActivationType, z: float) -> float",
      "apply_activation": "function alphalab.deep_learning.activations.apply_activation(activation: alphalab.deep_learning.activations.ActivationType, z: float) -> float",
      "apply_conv1d_gradients": "function alphalab.deep_learning.conv1d.apply_conv1d_gradients(layer: alphalab.deep_learning.conv1d.Conv1DLayer, gradients: alphalab.deep_learning.conv1d.Conv1DGradients, learning_rate: float) -> alphalab.deep_learning.conv1d.Conv1DLayer",
      "apply_gradients": "function alphalab.deep_learning.dense.apply_gradients(layer: alphalab.deep_learning.dense.DenseLayer, gradients: alphalab.deep_learning.dense.DenseGradients, learning_rate: float) -> alphalab.deep_learning.dense.DenseLayer",
      "apply_lstm_gradients": "function alphalab.deep_learning.lstm.apply_lstm_gradients(cell: alphalab.deep_learning.lstm.LSTMCell, gradients: alphalab.deep_learning.lstm.LSTMGradients, learning_rate: float) -> alphalab.deep_learning.lstm.LSTMCell",
      "apply_self_attention_gradients": "function alphalab.deep_learning.attention.apply_self_attention_gradients(layer: alphalab.deep_learning.attention.SelfAttentionLayer, gradients: alphalab.deep_learning.attention.SelfAttentionGradients, learning_rate: float) -> alphalab.deep_learning.attention.SelfAttentionLayer",
      "backward_conv1d": "function alphalab.deep_learning.conv1d.backward_conv1d(layer: alphalab.deep_learning.conv1d.Conv1DLayer, cache: alphalab.deep_learning.conv1d.Conv1DForwardCache, grad_output: tuple[float, ...]) -> alphalab.deep_learning.conv1d.Conv1DGradients",
      "backward_dense": "function alphalab.deep_learning.dense.backward_dense(layer: alphalab.deep_learning.dense.DenseLayer, cache: alphalab.deep_learning.dense.DenseForwardCache, grad_output: tuple[float, ...]) -> alphalab.deep_learning.dense.DenseGradients",
      "backward_self_attention": "function alphalab.deep_learning.attention.backward_self_attention(layer: alphalab.deep_learning.attention.SelfAttentionLayer, cache: alphalab.deep_learning.attention.SelfAttentionCache, grad_context: tuple[tuple[float, ...], ...]) -> alphalab.deep_learning.attention.SelfAttentionGradients",
      "create_conv1d_layer": "function alphalab.deep_learning.conv1d.create_conv1d_layer(kernel_size: int, activation: alphalab.deep_learning.activations.ActivationType, seed: int) -> alphalab.deep_learning.conv1d.Conv1DLayer",
      "create_dense_layer": "function alphalab.deep_learning.dense.create_dense_layer(n_inputs: int, n_outputs: int, activation: alphalab.deep_learning.activations.ActivationType, seed: int) -> alphalab.deep_learning.dense.DenseLayer",
      "create_lstm_cell": "function alphalab.deep_learning.lstm.create_lstm_cell(input_size: int, hidden_size: int, seed: int) -> alphalab.deep_learning.lstm.LSTMCell",
      "create_lstm_regressor": "function alphalab.deep_learning.lstm.create_lstm_regressor(input_size: int, hidden_size: int, output_size: int, seed: int, head_activation: alphalab.deep_learning.activations.ActivationType = <ActivationType.LINEAR: 1>) -> alphalab.deep_learning.lstm.LSTMRegressor",
      "create_self_attention_layer": "function alphalab.deep_learning.attention.create_self_attention_layer(input_size: int, key_size: int, value_size: int, seed: int) -> alphalab.deep_learning.attention.SelfAttentionLayer",
      "forward_conv1d": "function alphalab.deep_learning.conv1d.forward_conv1d(layer: alphalab.deep_learning.conv1d.Conv1DLayer, x: tuple[float, ...]) -> alphalab.deep_learning.conv1d.Conv1DForwardCache",
      "forward_dense": "function alphalab.deep_learning.dense.forward_dense(layer: alphalab.deep_learning.dense.DenseLayer, x: tuple[float, ...]) -> alphalab.deep_learning.dense.DenseForwardCache",
      "forward_network": "function alphalab.deep_learning.network.forward_network(network: alphalab.deep_learning.network.Sequential, x: tuple[float, ...]) -> tuple[tuple[alphalab.deep_learning.dense.DenseForwardCache, ...], tuple[float, ...]]",
      "forward_self_attention": "function alphalab.deep_learning.attention.forward_self_attention(layer: alphalab.deep_learning.attention.SelfAttentionLayer, sequence: tuple[tuple[float, ...], ...]) -> alphalab.deep_learning.attention.SelfAttentionCache",
      "gradients_match": "function alphalab.deep_learning.gradient_check.gradients_match(analytical: tuple[float, ...], numerical: tuple[float, ...], rtol: float = 0.01, atol: float = 0.0001) -> bool",
      "initial_lstm_state": "function alphalab.deep_learning.lstm.initial_lstm_state(hidden_size: int) -> alphalab.deep_learning.lstm.LSTMState",
      "lstm_backward": "function alphalab.deep_learning.lstm.lstm_backward(cell: alphalab.deep_learning.lstm.LSTMCell, steps: tuple[alphalab.deep_learning.lstm.LSTMStepCache, ...], grad_hidden: tuple[tuple[float, ...], ...], grad_final_cell: tuple[float, ...] | None = None) -> alphalab.deep_learning.lstm.LSTMGradients",
      "lstm_forward_sequence": "function alphalab.deep_learning.lstm.lstm_forward_sequence(cell: alphalab.deep_learning.lstm.LSTMCell, x_sequence: tuple[tuple[float, ...], ...], initial_state: alphalab.deep_learning.lstm.LSTMState | None = None) -> tuple[alphalab.deep_learning.lstm.LSTMState, ...]",
      "lstm_forward_step": "function alphalab.deep_learning.lstm.lstm_forward_step(cell: alphalab.deep_learning.lstm.LSTMCell, x: tuple[float, ...], prev_state: alphalab.deep_learning.lstm.LSTMState) -> alphalab.deep_learning.lstm.LSTMState",
      "lstm_sequence": "function alphalab.deep_learning.lstm.lstm_sequence(cell: alphalab.deep_learning.lstm.LSTMCell, x_sequence: tuple[tuple[float, ...], ...], initial_state: alphalab.deep_learning.lstm.LSTMState | None = None) -> tuple[alphalab.deep_learning.lstm.LSTMStepCache, ...]",
      "lstm_step": "function alphalab.deep_learning.lstm.lstm_step(cell: alphalab.deep_learning.lstm.LSTMCell, x: tuple[float, ...], prev_state: alphalab.deep_learning.lstm.LSTMState) -> alphalab.deep_learning.lstm.LSTMStepCache",
      "numerical_gradient": "function alphalab.deep_learning.gradient_check.numerical_gradient(f: collections.abc.Callable[[tuple[float, ...]], float], params: tuple[float, ...], epsilon: float = 1e-05) -> tuple[float, ...]",
      "predict_lstm": "function alphalab.deep_learning.lstm.predict_lstm(model: alphalab.deep_learning.lstm.LSTMRegressor, x_sequence: tuple[tuple[float, ...], ...]) -> tuple[float, ...]",
      "predict_network": "function alphalab.deep_learning.network.predict_network(network: alphalab.deep_learning.network.Sequential, x: tuple[float, ...]) -> tuple[float, ...]",
      "relu": "function alphalab.deep_learning.activations.relu(x: float) -> float",
      "relu_derivative": "function alphalab.deep_learning.activations.relu_derivative(x: float) -> float",
      "scaled_dot_product_attention": "function alphalab.deep_learning.attention.scaled_dot_product_attention(queries: tuple[tuple[float, ...], ...], keys: tuple[tuple[float, ...], ...], values: tuple[tuple[float, ...], ...]) -> alphalab.deep_learning.attention.AttentionOutput",
      "scaled_dot_product_attention_backward": "function alphalab.deep_learning.attention.scaled_dot_product_attention_backward(queries: tuple[tuple[float, ...], ...], keys: tuple[tuple[float, ...], ...], values: tuple[tuple[float, ...], ...], output: alphalab.deep_learning.attention.AttentionOutput, grad_context: tuple[tuple[float, ...], ...]) -> alphalab.deep_learning.attention.AttentionGradients",
      "sigmoid": "function alphalab.deep_learning.activations.sigmoid(x: float) -> float",
      "sigmoid_derivative": "function alphalab.deep_learning.activations.sigmoid_derivative(x: float) -> float",
      "softmax": "function alphalab.deep_learning.activations.softmax(values: tuple[float, ...]) -> tuple[float, ...]",
      "tanh_activation": "function alphalab.deep_learning.activations.tanh_activation(x: float) -> float",
      "tanh_derivative": "function alphalab.deep_learning.activations.tanh_derivative(x: float) -> float",
      "train_lstm": "function alphalab.deep_learning.lstm.train_lstm(model: alphalab.deep_learning.lstm.LSTMRegressor, sequences: tuple[tuple[tuple[float, ...], ...], ...], targets: tuple[tuple[float, ...], ...], learning_rate: float, epochs: int) -> tuple[alphalab.deep_learning.lstm.LSTMRegressor, tuple[float, ...]]",
      "train_lstm_step": "function alphalab.deep_learning.lstm.train_lstm_step(model: alphalab.deep_learning.lstm.LSTMRegressor, x_sequence: tuple[tuple[float, ...], ...], target: tuple[float, ...], learning_rate: float) -> tuple[alphalab.deep_learning.lstm.LSTMRegressor, float]",
      "train_network": "function alphalab.deep_learning.network.train_network(network: alphalab.deep_learning.network.Sequential, x: tuple[tuple[float, ...], ...], y: tuple[tuple[float, ...], ...], learning_rate: float, epochs: int) -> tuple[alphalab.deep_learning.network.Sequential, tuple[float, ...]]",
      "train_step": "function alphalab.deep_learning.network.train_step(network: alphalab.deep_learning.network.Sequential, x: tuple[float, ...], target: tuple[float, ...], learning_rate: float) -> tuple[alphalab.deep_learning.network.Sequential, float]"
    },
    "alphalab.deployment_manager": {
      "DeploymentManager": "class alphalab.deployment_manager.releases.DeploymentManager(releases: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.append_log.AppendOnlyLog[alphalab.deployment_manager.packaging.ReleasePackage]] = <factory>, deployments: alphalab.common.append_log.AppendOnlyLog[alphalab.deployment_manager.releases.DeploymentRecord] = <factory>, environments: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.append_log.AppendOnlyLog[alphalab.deployment_manager.releases.DeploymentRecord]] = <factory>) -> None",
      "DeploymentManagerError": "class alphalab.deployment_manager.exceptions.DeploymentManagerError",
      "DeploymentManagerInputError": "class alphalab.deployment_manager.exceptions.DeploymentManagerInputError",
      "DeploymentRecord": "class alphalab.deployment_manager.releases.DeploymentRecord(environment: str, release_name: str, version: int, replaced_version: int | None, is_rollback: bool, timestamp: float, actor_id: str = '') -> None",
      "ReleasePackage": "class alphalab.deployment_manager.packaging.ReleasePackage(name: str, version: int, components: collections.abc.Mapping[str, str], config: collections.abc.Mapping[str, str], checksum: str, created_at: float = 0.0) -> None",
      "active_release": "function alphalab.deployment_manager.deployment.active_release(manager: alphalab.deployment_manager.releases.DeploymentManager, environment: str) -> alphalab.deployment_manager.packaging.ReleasePackage | None",
      "build_release": "function alphalab.deployment_manager.packaging.build_release(name: str, version: int, components: collections.abc.Mapping[str, str], config: collections.abc.Mapping[str, str], timestamp: float) -> alphalab.deployment_manager.packaging.ReleasePackage",
      "compute_checksum": "function alphalab.deployment_manager.packaging.compute_checksum(components: collections.abc.Mapping[str, str], config: collections.abc.Mapping[str, str]) -> str",
      "deploy": "function alphalab.deployment_manager.deployment.deploy(manager: alphalab.deployment_manager.releases.DeploymentManager, name: str, version: int, environment: str, timestamp: float, actor_id: str = '') -> alphalab.deployment_manager.releases.DeploymentManager",
      "deployed_environments": "function alphalab.deployment_manager.deployment.deployed_environments(manager: alphalab.deployment_manager.releases.DeploymentManager) -> tuple[str, ...]",
      "deployment_history": "function alphalab.deployment_manager.rollback.deployment_history(manager: alphalab.deployment_manager.releases.DeploymentManager, environment: str | None = None) -> tuple[alphalab.deployment_manager.releases.DeploymentRecord, ...]",
      "get_release": "function alphalab.deployment_manager.releases.get_release(manager: alphalab.deployment_manager.releases.DeploymentManager, name: str, version: int) -> alphalab.deployment_manager.packaging.ReleasePackage",
      "latest_release": "function alphalab.deployment_manager.releases.latest_release(manager: alphalab.deployment_manager.releases.DeploymentManager, name: str) -> alphalab.deployment_manager.packaging.ReleasePackage",
      "list_releases": "function alphalab.deployment_manager.releases.list_releases(manager: alphalab.deployment_manager.releases.DeploymentManager, name: str) -> tuple[alphalab.deployment_manager.packaging.ReleasePackage, ...]",
      "previous_release": "function alphalab.deployment_manager.rollback.previous_release(manager: alphalab.deployment_manager.releases.DeploymentManager, environment: str) -> tuple[str, int] | None",
      "register_release": "function alphalab.deployment_manager.releases.register_release(manager: alphalab.deployment_manager.releases.DeploymentManager, name: str, components: collections.abc.Mapping[str, str], config: collections.abc.Mapping[str, str], timestamp: float) -> tuple[alphalab.deployment_manager.releases.DeploymentManager, alphalab.deployment_manager.packaging.ReleasePackage]",
      "release_names": "function alphalab.deployment_manager.releases.release_names(manager: alphalab.deployment_manager.releases.DeploymentManager) -> tuple[str, ...]",
      "rollback": "function alphalab.deployment_manager.rollback.rollback(manager: alphalab.deployment_manager.releases.DeploymentManager, environment: str, timestamp: float, actor_id: str = '') -> alphalab.deployment_manager.releases.DeploymentManager",
      "verify_checksum": "function alphalab.deployment_manager.packaging.verify_checksum(package: alphalab.deployment_manager.packaging.ReleasePackage) -> bool"
    },
    "alphalab.distributed": {
      "DistributedAdapter": "class alphalab.distributed.adapter.DistributedAdapter()",
      "DistributedEngine": "class alphalab.distributed.engine.DistributedEngine()",
      "DistributedError": "class alphalab.distributed.exceptions.DistributedError",
      "DistributedEvent": "class alphalab.distributed.events.DistributedEvent(event_id: str, timestamp: float) -> None",
      "DistributedState": "class alphalab.distributed.state.DistributedState(cluster_id: str, workers: alphalab.common.persistent_map.PersistentMap[str, alphalab.distributed.node.WorkerNode] = <factory>, queued_jobs: alphalab.common.append_log.AppendOnlyLog[alphalab.distributed.job.Job] = <factory>, queued_ids: alphalab.common.persistent_map.PersistentSet[str] = <factory>, running_jobs: alphalab.common.persistent_map.PersistentMap[str, alphalab.distributed.job.Job] = <factory>, completed_jobs: alphalab.common.persistent_map.PersistentMap[str, alphalab.distributed.job.Job] = <factory>, failed_jobs: alphalab.common.persistent_map.PersistentMap[str, alphalab.distributed.job.Job] = <factory>, cancelled_jobs: alphalab.common.persistent_map.PersistentMap[str, alphalab.distributed.job.Job] = <factory>, statistics: alphalab.distributed.state.DistributedStatistics = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.distributed.events.DistributedEvent] = <factory>, metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "DistributedStatistics": "class alphalab.distributed.state.DistributedStatistics(total_jobs_submitted: int = 0, total_jobs_completed: int = 0, total_jobs_failed: int = 0, total_jobs_cancelled: int = 0) -> None",
      "DistributedValidationError": "class alphalab.distributed.exceptions.DistributedValidationError",
      "InvalidJobStateError": "class alphalab.distributed.exceptions.InvalidJobStateError",
      "InvalidNodeStateError": "class alphalab.distributed.exceptions.InvalidNodeStateError",
      "Job": "class alphalab.distributed.job.Job(job_id: str, job_type: alphalab.distributed.job.JobType, status: alphalab.distributed.job.JobStatus, priority: int, created_timestamp: float, started_timestamp: float = 0.0, completed_timestamp: float = 0.0, worker_id: str | None = None, payload: collections.abc.Mapping[str, Any] = <factory>, metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "JobAssigned": "class alphalab.distributed.events.JobAssigned(event_id: str, timestamp: float, job_id: str, worker_id: str) -> None",
      "JobCancelled": "class alphalab.distributed.events.JobCancelled(event_id: str, timestamp: float, job_id: str, worker_id: str) -> None",
      "JobCompleted": "class alphalab.distributed.events.JobCompleted(event_id: str, timestamp: float, job_id: str, worker_id: str, execution_time: float) -> None",
      "JobCoordinator": "class alphalab.distributed.coordinator.JobCoordinator()",
      "JobFailed": "class alphalab.distributed.events.JobFailed(event_id: str, timestamp: float, job_id: str, worker_id: str, reason: str) -> None",
      "JobQueue": "class alphalab.distributed.queue.JobQueue()",
      "JobRunnerProtocol": "class alphalab.distributed.protocol.JobRunnerProtocol(*args, **kwargs)",
      "JobScheduler": "class alphalab.distributed.scheduler.JobScheduler()",
      "JobStarted": "class alphalab.distributed.events.JobStarted(event_id: str, timestamp: float, job_id: str, worker_id: str) -> None",
      "JobStatus": "enum alphalab.distributed.job.JobStatus[PENDING, ASSIGNED, RUNNING, COMPLETED, FAILED, CANCELLED]",
      "JobSubmitted": "class alphalab.distributed.events.JobSubmitted(event_id: str, timestamp: float, job_id: str, job_type: str, priority: int) -> None",
      "JobType": "enum alphalab.distributed.job.JobType[BACKTEST, OPTIMIZATION, REPLAY, ANALYTICS, REPORT, PLUGIN_TASK]",
      "WorkerNode": "class alphalab.distributed.node.WorkerNode(node_id: str, hostname: str, status: alphalab.distributed.node.WorkerStatus, capacity: int, running_jobs: tuple[str, ...] = <factory>, completed_jobs: int = 0, metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "WorkerRegistered": "class alphalab.distributed.events.WorkerRegistered(event_id: str, timestamp: float, worker_id: str, capacity: int) -> None",
      "WorkerRegistry": "class alphalab.distributed.registry.WorkerRegistry()",
      "WorkerRemoved": "class alphalab.distributed.events.WorkerRemoved(event_id: str, timestamp: float, worker_id: str) -> None",
      "WorkerStatus": "enum alphalab.distributed.node.WorkerStatus[IDLE, BUSY, OFFLINE]",
      "active_workers": "function alphalab.distributed.views.active_workers(state: alphalab.distributed.state.DistributedState) -> collections.abc.Sequence[alphalab.distributed.node.WorkerNode]",
      "cancelled_jobs": "function alphalab.distributed.views.cancelled_jobs(state: alphalab.distributed.state.DistributedState) -> collections.abc.Sequence[alphalab.distributed.job.Job]",
      "cluster_statistics": "function alphalab.distributed.views.cluster_statistics(state: alphalab.distributed.state.DistributedState) -> alphalab.distributed.state.DistributedStatistics",
      "completed_jobs": "function alphalab.distributed.views.completed_jobs(state: alphalab.distributed.state.DistributedState) -> collections.abc.Sequence[alphalab.distributed.job.Job]",
      "failed_jobs": "function alphalab.distributed.views.failed_jobs(state: alphalab.distributed.state.DistributedState) -> collections.abc.Sequence[alphalab.distributed.job.Job]",
      "queue_length": "function alphalab.distributed.views.queue_length(state: alphalab.distributed.state.DistributedState) -> int",
      "running_jobs": "function alphalab.distributed.views.running_jobs(state: alphalab.distributed.state.DistributedState) -> collections.abc.Sequence[alphalab.distributed.job.Job]",
      "validate_job_submission": "function alphalab.distributed.validation.validate_job_submission(state: alphalab.distributed.state.DistributedState, job: alphalab.distributed.job.Job) -> None",
      "validate_job_transition": "function alphalab.distributed.validation.validate_job_transition(job: alphalab.distributed.job.Job, target_status: alphalab.distributed.job.JobStatus) -> None",
      "validate_worker_registration": "function alphalab.distributed.validation.validate_worker_registration(state: alphalab.distributed.state.DistributedState, worker: alphalab.distributed.node.WorkerNode) -> None",
      "worker_utilization": "function alphalab.distributed.views.worker_utilization(state: alphalab.distributed.state.DistributedState) -> dict[str, float]"
    },
    "alphalab.execution": {
      "ALGORITHM_CONFIGURATION_SCHEME": "value builtins.str",
      "ALGORITHM_RUN_SCHEME": "value builtins.str",
      "AlgorithmState": "class alphalab.execution.algorithms.AlgorithmState(parent: 'OrderRequest', algorithm: 'ExecutionAlgorithm', terms: 'AlgorithmTerms', algorithm_id: 'str', schedule: 'ExecutionSchedule | None', children: 'PersistentMap[str, ChildProgress]' = <factory>, released: 'Decimal' = Decimal('0'), filled: 'Decimal' = Decimal('0'), returned: 'Decimal' = Decimal('0'), executions: 'PersistentSet[str]' = <factory>, observed_volume: 'Decimal' = Decimal('0'), observed_until: 'float | None' = None, status: 'AlgorithmStatus' = <AlgorithmStatus.WORKING: 'working'>, reason: 'str' = '', notes: 'tuple[str, ...]' = ()) -> None",
      "AlgorithmStatus": "enum alphalab.execution.algorithms.AlgorithmStatus[WORKING, COMPLETED, CANCELLED, EXPIRED, FAILED]",
      "AlgorithmTerms": "class alphalab.execution.algorithms.AlgorithmTerms(start: 'float', end: 'float', quantity_increment: 'Decimal', order_type: 'OrderType', limit_price: 'Decimal | None') -> None",
      "AssetCapacity": "class alphalab.execution.capacity.AssetCapacity(asset_id: 'str', participation_capacity: 'Decimal', impact_capacity: 'Decimal | None', capacity: 'Decimal', constraint: 'CapacityConstraint', participation_at_capacity: 'Decimal') -> None",
      "AssetLiquidity": "class alphalab.execution.capacity.AssetLiquidity(asset_id: 'str', price: 'Decimal', average_daily_volume: 'Decimal', weight: 'Decimal', currency: 'str', venue: 'str') -> None",
      "CandidateStatus": "enum alphalab.execution.routing.CandidateStatus[ELIGIBLE, INELIGIBLE, INSUFFICIENT_EVIDENCE, EXCLUDED]",
      "CapacityConstraint": "enum alphalab.execution.capacity.CapacityConstraint[PARTICIPATION, IMPACT_BUDGET, UNBOUND]",
      "CapacityModel": "class alphalab.execution.capacity.CapacityModel(participation_limit: 'Decimal', turnover: 'Decimal', impact_model: 'ImpactModel', impact_budget: 'Decimal | None', search_ceiling: 'Decimal') -> None",
      "CapacityResult": "class alphalab.execution.capacity.CapacityResult(capacity: 'Decimal', constraint: 'CapacityConstraint', binding_asset_id: 'str | None', per_asset: 'tuple[AssetCapacity, ...]', assumptions: 'Mapping[str, str]') -> None",
      "ChildOrder": "class alphalab.execution.algorithms.ChildOrder(child_id: 'str', parent_order_id: 'str', sequence: 'int', asset_id: 'str', side: 'Side', quantity: 'Decimal', order_type: 'OrderType', limit_price: 'Decimal | None', released_at: 'float', expires_at: 'float | None', strategy_id: 'str', contributions: 'tuple[StrategyContribution, ...]', algorithm_id: 'str') -> None",
      "ChildProgress": "class alphalab.execution.algorithms.ChildProgress(child: 'ChildOrder', filled: 'Decimal', outcome: 'OrderStatus | None') -> None",
      "ClockSource": "enum alphalab.execution.quality.ClockSource[LOCAL, VENUE]",
      "CommissionModel": "class alphalab.execution.commission.CommissionModel(*args, **kwargs)",
      "ConstantLatency": "class alphalab.execution.latency.ConstantLatency(latency: 'float') -> 'None'",
      "CostContext": "class alphalab.execution.costs.CostContext(asset_id: 'str', side: 'Side', quantity: 'Decimal', reference_price: 'Decimal', currency: 'str', venue: 'str', timestamp: 'float', bid: 'Decimal | None' = None, ask: 'Decimal | None' = None, available_liquidity: 'Decimal | None' = None, minor_units: 'int | None' = None) -> None",
      "CostSettlement": "enum alphalab.execution.costs.CostSettlement[PRICE_EMBEDDED, CASH_CHARGED]",
      "DeterministicLatency": "class alphalab.execution.latency.DeterministicLatency(min_lat: 'float', max_lat: 'float') -> 'None'",
      "EXECUTION_QUALITY_SCHEME": "value builtins.str",
      "EXECUTION_SCHEDULE_SCHEME": "value builtins.str",
      "ExecutionAlgorithm": "alias ExecutionAlgorithm",
      "ExecutionBenchmarks": "class alphalab.execution.quality.ExecutionBenchmarks(decision_price: 'Decimal | None', arrival_price: 'Decimal | None', interval_vwap: 'Decimal | None', end_price: 'Decimal | None', source: 'str') -> None",
      "ExecutionCompleted": "class alphalab.execution.events.ExecutionCompleted(event_id: str, timestamp: float, order_id: str, execution_id: str, fill_price: decimal.Decimal, fill_quantity: decimal.Decimal) -> None",
      "ExecutionCostModel": "class alphalab.execution.costs.ExecutionCostModel(spread_model: 'SpreadModel', slippage_model: 'SlippageModel', impact_model: 'ImpactModel', commission_model: 'CommissionModel', fee_model: 'FeeModel', tax_model: 'TaxModel') -> None",
      "ExecutionCosts": "class alphalab.execution.costs.ExecutionCosts(spread: 'Decimal', slippage: 'Decimal', impact: 'Decimal', commission: 'Decimal', fees: 'Decimal', tax: 'Decimal') -> None",
      "ExecutionEngine": "class alphalab.execution.engine.ExecutionEngine()",
      "ExecutionError": "class alphalab.execution.exceptions.ExecutionError",
      "ExecutionEvent": "class alphalab.execution.events.ExecutionEvent(event_id: str, timestamp: float, order_id: str) -> None",
      "ExecutionExpired": "class alphalab.execution.events.ExecutionExpired(event_id: str, timestamp: float, order_id: str) -> None",
      "ExecutionPartiallyFilled": "class alphalab.execution.events.ExecutionPartiallyFilled(event_id: str, timestamp: float, order_id: str, execution_id: str, fill_price: decimal.Decimal, fill_quantity: decimal.Decimal, remaining_quantity: decimal.Decimal) -> None",
      "ExecutionQualityReport": "class alphalab.execution.quality.ExecutionQualityReport(shortfalls: 'tuple[ImplementationShortfall, ...]', total_by_currency: 'Mapping[str, Decimal]', reporting_currency: 'str | None', reporting_total: 'Decimal | None', conversions: 'tuple[ConversionRecord, ...]', conversion_at: 'float | None', strategy_totals: 'Mapping[str, Mapping[str, Decimal]]', incomplete_orders: 'tuple[str, ...]', assumptions: 'tuple[str, ...]') -> None",
      "ExecutionRejected": "class alphalab.execution.events.ExecutionRejected(event_id: str, timestamp: float, order_id: str, reason: str) -> None",
      "ExecutionReport": "class alphalab.execution.report.ExecutionReport(execution_id: str, order_id: str, asset_id: str, strategy_id: str, timestamp: float, fill_price: decimal.Decimal, fill_quantity: decimal.Decimal, commission: decimal.Decimal, slippage: decimal.Decimal, liquidity_flag: str, venue: str, currency: str, status: alphalab.execution.fill.FillStatus) -> None",
      "ExecutionSchedule": "class alphalab.execution.algorithms.ExecutionSchedule(slices: 'tuple[ScheduledSlice, ...]', basis: 'ScheduleBasis', note: 'str') -> None",
      "ExecutionSimulator": "class alphalab.execution.simulator.ExecutionSimulator(commission_model: alphalab.execution.commission.CommissionModel = <alphalab.execution.commission.FixedCommission object>, slippage_model: alphalab.execution.slippage.SlippageModel = <alphalab.execution.slippage.FixedSlippage object>, latency_model: alphalab.execution.latency.LatencyModel = <alphalab.execution.latency.ConstantLatency object>, cost_model: alphalab.execution.costs.ExecutionCostModel | None = None, maker_commission_model: alphalab.execution.commission.CommissionModel | None = None) -> None",
      "ExecutionState": "class alphalab.execution.state.ExecutionState(reports: alphalab.common.persistent_map.PersistentMap[str, alphalab.execution.report.ExecutionReport] = <factory>, history: alphalab.common.append_log.AppendOnlyLog[alphalab.execution.report.ExecutionReport] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.execution.events.ExecutionEvent] = <factory>) -> None",
      "ExecutionSubmitted": "class alphalab.execution.events.ExecutionSubmitted(event_id: str, timestamp: float, order_id: str, asset_id: str, quantity: decimal.Decimal, price: decimal.Decimal) -> None",
      "ExecutionValidationError": "class alphalab.execution.exceptions.ExecutionValidationError",
      "FREE": "value alphalab.execution.costs.ExecutionCostModel",
      "FeeModel": "class alphalab.execution.costs.FeeModel(*args, **kwargs)",
      "FillDecision": "class alphalab.execution.policy.FillDecision(status: alphalab.execution.fill.FillStatus, quantity: decimal.Decimal | None = None) -> None",
      "FillPolicy": "class alphalab.execution.policy.FillPolicy(*args, **kwargs)",
      "FillQuality": "class alphalab.execution.quality.FillQuality(order_id: 'str', outcome: 'OrderStatus', ordered_quantity: 'Decimal', filled_quantity: 'Decimal', fill_ratio: 'Decimal', fill_count: 'int', average_fill_price: 'Decimal | None', limit_improvement_per_unit: 'Decimal | None', effective_spread_bps: 'Decimal | None', unavailable: 'Mapping[str, str]') -> None",
      "FillStatus": "enum alphalab.execution.fill.FillStatus[FULL_FILL, PARTIAL_FILL, NO_FILL, REJECTED, EXPIRED]",
      "FillTiming": "enum alphalab.execution.policy.FillTiming[SAME_EVENT, NEXT_EVENT]",
      "FixedCommission": "class alphalab.execution.commission.FixedCommission(fee: decimal.Decimal) -> None",
      "FixedHalfSpread": "class alphalab.execution.costs.FixedHalfSpread(amount: 'Decimal') -> None",
      "FixedSlippage": "class alphalab.execution.slippage.FixedSlippage(slippage_amount: decimal.Decimal) -> None",
      "Iceberg": "class alphalab.execution.algorithms.Iceberg(display_quantity: 'Decimal', randomization: 'TrancheRandomization | None' = None) -> None",
      "ImmediateFill": "class alphalab.execution.policy.ImmediateFill() -> None",
      "ImpactModel": "class alphalab.execution.costs.ImpactModel(*args, **kwargs)",
      "ImplementationShortfall": "class alphalab.execution.quality.ImplementationShortfall(order_id: 'str', asset_id: 'str', side: 'Side', currency: 'str', ordered_quantity: 'Decimal', filled_quantity: 'Decimal', unfilled_quantity: 'Decimal', decision_price: 'Decimal', arrival_price: 'Decimal | None', end_price: 'Decimal | None', average_fill_price: 'Decimal | None', paper_notional: 'Decimal', execution_cost: 'Decimal', delay_cost: 'Decimal | None', trading_cost: 'Decimal | None', explicit_costs: 'Decimal', opportunity_cost: 'Decimal | None', total: 'Decimal | None', total_bps: 'Decimal | None', strategy_shares: 'tuple[tuple[str, Decimal], ...]', execution_ids: 'tuple[str, ...]', venues: 'tuple[str, ...]', assumptions: 'tuple[str, ...]', unavailable: 'Mapping[str, str]') -> None",
      "IncompletePolicy": "enum alphalab.execution.algorithms.IncompletePolicy[LEAVE_UNFILLED, COMPLETE_AT_END]",
      "IntervalVolume": "class alphalab.execution.algorithms.IntervalVolume(start: 'float', end: 'float', volume: 'Decimal | None') -> None",
      "LatencyMeasurement": "class alphalab.execution.quality.LatencyMeasurement(order_id: 'str', venue: 'str', start: 'LifecycleMark', end: 'LifecycleMark', seconds: 'Decimal | None', start_clock: 'ClockSource | None', end_clock: 'ClockSource | None', mixed_clocks: 'bool', reason: 'str') -> None",
      "LatencyModel": "class alphalab.execution.latency.LatencyModel(*args, **kwargs)",
      "LifecycleMark": "enum alphalab.execution.quality.LifecycleMark[DECISION, SUBMISSION, ACKNOWLEDGEMENT, FIRST_FILL, LAST_FILL, TERMINAL]",
      "LinearImpact": "class alphalab.execution.costs.LinearImpact(coefficient: 'Decimal') -> None",
      "LiquidityCappedFill": "class alphalab.execution.policy.LiquidityCappedFill(participation_rate: decimal.Decimal = Decimal('1')) -> None",
      "LiquidityContext": "class alphalab.execution.policy.LiquidityContext(asset_id: str, side: alphalab.core.enums.Side, requested_quantity: decimal.Decimal, price: decimal.Decimal, available_quantity: decimal.Decimal | None, timestamp: float) -> None",
      "MAX_SPLIT_FIXED_CHARGE_VENUES": "value builtins.int",
      "MAX_URGENCY": "value decimal.Decimal",
      "MarketImpactSlippage": "class alphalab.execution.slippage.MarketImpactSlippage(impact_factor: decimal.Decimal, reference_quantity: decimal.Decimal) -> None",
      "MissingVolumePolicy": "enum alphalab.execution.algorithms.MissingVolumePolicy[REFUSE, TIME_WEIGHTED]",
      "NoFee": "class alphalab.execution.costs.NoFee() -> None",
      "NoImpact": "class alphalab.execution.costs.NoImpact() -> None",
      "NoSlippage": "class alphalab.execution.costs.NoSlippage() -> None",
      "NoSpread": "class alphalab.execution.costs.NoSpread() -> None",
      "NoTax": "class alphalab.execution.costs.NoTax() -> None",
      "OrderExecution": "class alphalab.execution.quality.OrderExecution(order: 'OrderRequest', fills: 'tuple[ExecutionReport, ...]', currency: 'str', outcome: 'OrderStatus', benchmarks: 'ExecutionBenchmarks', limit_price: 'Decimal | None', timeline: 'OrderTimeline | None', fill_midpoints: 'Mapping[str, Decimal] | None', account_id: 'str | None') -> None",
      "OrderInstruction": "class alphalab.execution.fill.OrderInstruction(order_id: str, strategy_id: str, asset_id: str, quantity: decimal.Decimal, price: decimal.Decimal, side: alphalab.core.enums.Side, venue: str, currency: str, minor_units: int | None = None) -> None",
      "OrderOutcome": "class alphalab.execution.quality.OrderOutcome(order_id: 'str', venue: 'str', submitted_at: 'float', status: 'OrderStatus') -> None",
      "OrderTimeline": "class alphalab.execution.quality.OrderTimeline(order_id: 'str', venue: 'str', marks: 'tuple[TimelineMark, ...]') -> None",
      "Participation": "class alphalab.execution.algorithms.Participation(rate: 'Decimal', min_child_quantity: 'Decimal | None', max_child_quantity: 'Decimal | None', at_end: 'IncompletePolicy') -> None",
      "PerShareCommission": "class alphalab.execution.commission.PerShareCommission(rate_per_share: decimal.Decimal) -> None",
      "PerTradeFee": "class alphalab.execution.costs.PerTradeFee(amount: 'Decimal') -> None",
      "PercentageCommission": "class alphalab.execution.commission.PercentageCommission(rate: decimal.Decimal) -> None",
      "PercentageSlippage": "class alphalab.execution.slippage.PercentageSlippage(rate: decimal.Decimal) -> None",
      "ProportionalFee": "class alphalab.execution.costs.ProportionalFee(fraction: 'Decimal') -> None",
      "ProportionalTax": "class alphalab.execution.costs.ProportionalTax(fraction: 'Decimal', sides: 'frozenset[Side]') -> None",
      "QuotedHalfSpread": "class alphalab.execution.costs.QuotedHalfSpread() -> None",
      "ROUTE_DECISION_SCHEME": "value builtins.str",
      "ROUTING_POLICY_SCHEME": "value builtins.str",
      "ReferencePrice": "enum alphalab.execution.quality.ReferencePrice[DECISION, ARRIVAL, INTERVAL_VWAP]",
      "RejectionRate": "class alphalab.execution.quality.RejectionRate(window_start: 'float', window_end: 'float', venue: 'str | None', submitted: 'int', resolved: 'int', rejected: 'int', unresolved: 'int', rate: 'Decimal | None') -> None",
      "RouteCandidate": "class alphalab.execution.routing.RouteCandidate(venue: 'str', status: 'CandidateStatus', reason: 'str', quoted_price: 'Decimal | None', displayed_quantity: 'Decimal | None', executable_quantity: 'Decimal', expected_price: 'Decimal | None', all_in_price: 'Decimal | None', expected_costs: 'ExecutionCosts | None', latency_seconds: 'Decimal | None', compatibility: 'CompatibilityReport | None', rank: 'int | None') -> None",
      "RouteDecision": "class alphalab.execution.routing.RouteDecision(request: 'RouteRequest', policy: 'RoutingPolicy', status: 'RouteStatus', legs: 'tuple[RouteLeg, ...]', candidates: 'tuple[RouteCandidate, ...]', reason: 'str', evidence_id: 'str') -> None",
      "RouteLeg": "class alphalab.execution.routing.RouteLeg(venue: 'str', quantity: 'Decimal', quoted_price: 'Decimal', expected_price: 'Decimal', expected_costs: 'ExecutionCosts', all_in_price: 'Decimal') -> None",
      "RouteRequest": "class alphalab.execution.routing.RouteRequest(order_id: 'str', asset_id: 'str', side: 'Side', quantity: 'Decimal', limit_price: 'Decimal | None', currency: 'str', requirements: 'ExecutionRequirements', quantity_increment: 'Decimal', decided_at: 'float') -> None",
      "RouteStatus": "enum alphalab.execution.routing.RouteStatus[ROUTED, PARTIAL, INFEASIBLE, INSUFFICIENT_EVIDENCE]",
      "RoutingObjective": "enum alphalab.execution.routing.RoutingObjective[BEST_QUOTED_PRICE, LOWEST_ALL_IN_COST]",
      "RoutingPolicy": "class alphalab.execution.routing.RoutingPolicy(objective: 'RoutingObjective', max_quote_age_seconds: 'float', max_latency_seconds: 'Decimal | None', allow_split: 'bool', allow_partial: 'bool', excluded_venues: 'frozenset[str]', split_method: 'SplitMethod' = <SplitMethod.GREEDY_SWEEP: 'greedy_sweep'>) -> None",
      "ScheduleBasis": "enum alphalab.execution.algorithms.ScheduleBasis[TIME, VOLUME, TIME_FALLBACK]",
      "ScheduleCost": "class alphalab.execution.algorithms.ScheduleCost(quantity: 'Decimal', trades: 'tuple[Decimal, ...]', interval: 'Decimal', permanent: 'Decimal', fixed: 'Decimal', temporary: 'Decimal', expected: 'Decimal', variance: 'Decimal', standard_deviation: 'Decimal', volatility: 'Decimal', temporary_impact: 'Decimal', permanent_impact: 'Decimal', fixed_cost: 'Decimal', horizon: 'Decimal') -> None",
      "ScheduledSlice": "class alphalab.execution.algorithms.ScheduledSlice(index: 'int', start: 'float', end: 'float', weight: 'Decimal', quantity: 'Decimal', target: 'Decimal') -> None",
      "ShortfallAgainstModel": "class alphalab.execution.quality.ShortfallAgainstModel(order_id: 'str', currency: 'str', quantity: 'Decimal', realized: 'Decimal', expected: 'Decimal', standard_deviation: 'Decimal', difference: 'Decimal', standard_deviations: 'Decimal | None') -> None",
      "Slicing": "class alphalab.execution.algorithms.Slicing(slice_quantity: 'Decimal | None', slice_count: 'int | None') -> None",
      "SlippageMeasurement": "class alphalab.execution.quality.SlippageMeasurement(order_id: 'str', reference: 'ReferencePrice', reference_price: 'Decimal | None', average_fill_price: 'Decimal | None', filled_quantity: 'Decimal', currency: 'str', per_unit: 'Decimal | None', amount: 'Decimal | None', bps: 'Decimal | None', reason: 'str') -> None",
      "SlippageModel": "class alphalab.execution.slippage.SlippageModel(*args, **kwargs)",
      "SplitMethod": "enum alphalab.execution.routing.SplitMethod[GREEDY_SWEEP, OPTIMAL]",
      "SpreadModel": "class alphalab.execution.costs.SpreadModel(*args, **kwargs)",
      "SquareRootImpact": "class alphalab.execution.costs.SquareRootImpact(coefficient: 'Decimal') -> None",
      "StaticFill": "class alphalab.execution.policy.StaticFill(status: alphalab.execution.fill.FillStatus = <FillStatus.FULL_FILL: 1>, quantity: decimal.Decimal | None = None) -> None",
      "TWAP": "class alphalab.execution.algorithms.TWAP(slices: 'int', urgency: 'Urgency') -> None",
      "TaxModel": "class alphalab.execution.costs.TaxModel(*args, **kwargs)",
      "TimelineMark": "class alphalab.execution.quality.TimelineMark(mark: 'LifecycleMark', at: 'float', clock: 'ClockSource') -> None",
      "TrancheRandomization": "class alphalab.execution.algorithms.TrancheRandomization(spread: 'Decimal', seed: 'int') -> None",
      "Urgency": "class alphalab.execution.algorithms.Urgency(kappa: 'Decimal') -> None",
      "UrgencyEstimate": "class alphalab.execution.algorithms.UrgencyEstimate(risk_aversion: 'Decimal', volatility: 'Decimal', temporary_impact: 'Decimal', permanent_impact: 'Decimal', horizon: 'Decimal', slices: 'int', kappa: 'Decimal', urgency: 'Urgency') -> None",
      "VWAP": "class alphalab.execution.algorithms.VWAP(profile: 'VolumeProfile', missing_volume: 'MissingVolumePolicy', urgency: 'Urgency') -> None",
      "VenueProfile": "class alphalab.execution.routing.VenueProfile(venue: 'str', capabilities: 'CapabilityDeclaration', costs: 'ExecutionCostModel', latency_seconds: 'Decimal | None') -> None",
      "VenueQuality": "class alphalab.execution.quality.VenueQuality(venue: 'str', currency: 'str | None', fills: 'int', filled_quantity: 'Decimal', slippage_reference: 'ReferencePrice', slippage_bps: 'Decimal | None', unmeasured_fills: 'int', rejection_rate: 'RejectionRate', acknowledgement_seconds_median: 'Decimal | None') -> None",
      "VenueQuote": "class alphalab.execution.routing.VenueQuote(venue: 'str', asset_id: 'str', bid: 'Decimal | None', ask: 'Decimal | None', bid_size: 'Decimal | None', ask_size: 'Decimal | None', currency: 'str', as_of: 'float', source: 'str') -> None",
      "VolumeProfile": "class alphalab.execution.algorithms.VolumeProfile(intervals: 'tuple[IntervalVolume, ...]', source: 'str') -> None",
      "algorithm_configuration_id": "function alphalab.execution.algorithms.algorithm_configuration_id(algorithm: 'ExecutionAlgorithm') -> 'str'",
      "all_reports": "function alphalab.execution.views.all_reports(state: alphalab.execution.state.ExecutionState) -> collections.abc.Sequence[alphalab.execution.report.ExecutionReport]",
      "cancel_algorithm": "function alphalab.execution.algorithms.cancel_algorithm(state: 'AlgorithmState', now: 'float', reason: 'str') -> 'tuple[AlgorithmState, tuple[ChildOrder, ...]]'",
      "capacity_curve": "function alphalab.execution.capacity.capacity_curve(model: 'CapacityModel', universe: 'Sequence[AssetLiquidity]', capital_levels: 'Sequence[Decimal]', timestamp: 'float') -> 'tuple[tuple[Decimal, Decimal, Decimal], ...]'",
      "estimate_urgency": "function alphalab.execution.algorithms.estimate_urgency(*, risk_aversion: 'Decimal', volatility: 'Decimal', temporary_impact: 'Decimal', permanent_impact: 'Decimal', horizon: 'Decimal', slices: 'int') -> 'UrgencyEstimate'",
      "execution_quality_report": "function alphalab.execution.quality.execution_quality_report(executions: 'Sequence[OrderExecution]', *, reporting_currency: 'str | None', converter: 'CurrencyConverter | None', conversion_at: 'float | None') -> 'ExecutionQualityReport'",
      "fill_quality": "function alphalab.execution.quality.fill_quality(execution: 'OrderExecution') -> 'FillQuality'",
      "implementation_shortfall": "function alphalab.execution.quality.implementation_shortfall(execution: 'OrderExecution') -> 'ImplementationShortfall'",
      "itemized": "function alphalab.execution.costs.itemized(costs: 'ExecutionCosts', quantity: 'Decimal') -> 'Mapping[str, Decimal]'",
      "measure_latency": "function alphalab.execution.quality.measure_latency(timeline: 'OrderTimeline', start: 'LifecycleMark', end: 'LifecycleMark') -> 'LatencyMeasurement'",
      "measure_slippage": "function alphalab.execution.quality.measure_slippage(execution: 'OrderExecution', reference: 'ReferencePrice') -> 'SlippageMeasurement'",
      "plan_schedule": "function alphalab.execution.algorithms.plan_schedule(parent_quantity: 'Decimal', algorithm: 'TWAP | VWAP', terms: 'AlgorithmTerms') -> 'ExecutionSchedule'",
      "reconciles": "function alphalab.execution.costs.reconciles(costs: 'ExecutionCosts', concession: 'Decimal', cash: 'Decimal') -> 'bool'",
      "record_child_execution": "function alphalab.execution.algorithms.record_child_execution(state: 'AlgorithmState', child_id: 'str', execution_id: 'str', quantity: 'Decimal', timestamp: 'float') -> 'AlgorithmState'",
      "record_child_outcome": "function alphalab.execution.algorithms.record_child_outcome(state: 'AlgorithmState', child_id: 'str', outcome: 'OrderStatus', timestamp: 'float') -> 'AlgorithmState'",
      "rejection_rate": "function alphalab.execution.quality.rejection_rate(outcomes: 'Sequence[OrderOutcome]', *, window_start: 'float', window_end: 'float', venue: 'str | None') -> 'RejectionRate'",
      "release_children": "function alphalab.execution.algorithms.release_children(state: 'AlgorithmState', now: 'float', volumes: 'Sequence[IntervalVolume]' = ()) -> 'tuple[AlgorithmState, tuple[ChildOrder, ...]]'",
      "report": "function alphalab.execution.views.report(state: alphalab.execution.state.ExecutionState, execution_id: str) -> alphalab.execution.report.ExecutionReport | None",
      "reports_for_asset": "function alphalab.execution.views.reports_for_asset(state: alphalab.execution.state.ExecutionState, asset_id: str) -> collections.abc.Sequence[alphalab.execution.report.ExecutionReport]",
      "reports_for_order": "function alphalab.execution.views.reports_for_order(state: alphalab.execution.state.ExecutionState, order_id: str) -> collections.abc.Sequence[alphalab.execution.report.ExecutionReport]",
      "schedule_cost": "function alphalab.execution.algorithms.schedule_cost(trades: 'Sequence[Decimal]', *, volatility: 'Decimal', temporary_impact: 'Decimal', permanent_impact: 'Decimal', fixed_cost: 'Decimal', horizon: 'Decimal') -> 'ScheduleCost'",
      "select_route": "function alphalab.execution.routing.select_route(request: 'RouteRequest', quotes: 'Sequence[VenueQuote]', profiles: 'Sequence[VenueProfile]', policy: 'RoutingPolicy') -> 'RouteDecision'",
      "shortfall_against_model": "function alphalab.execution.quality.shortfall_against_model(shortfall: 'ImplementationShortfall', model: 'ScheduleCost') -> 'ShortfallAgainstModel'",
      "start_algorithm": "function alphalab.execution.algorithms.start_algorithm(parent: 'OrderRequest', algorithm: 'ExecutionAlgorithm', terms: 'AlgorithmTerms') -> 'AlgorithmState'",
      "validate_execution_parameters": "function alphalab.execution.validation.validate_execution_parameters(quantity: decimal.Decimal, price: decimal.Decimal, commission: decimal.Decimal, timestamp: float) -> None",
      "venue_quality": "function alphalab.execution.quality.venue_quality(executions: 'Sequence[OrderExecution]', outcomes: 'Sequence[OrderOutcome]', *, reference: 'ReferencePrice', window_start: 'float', window_end: 'float') -> 'tuple[VenueQuality, ...]'"
    },
    "alphalab.experiment_tracking": {
      "ExperimentRun": "class alphalab.experiment_tracking.tracker.ExperimentRun(run_id: str, name: str, status: alphalab.experiment_tracking.tracker.RunStatus, parameters: collections.abc.Mapping[str, ParamValue], metrics: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.append_log.AppendOnlyLog[float]] = <factory>, parent_run_id: str | None = None, tags: collections.abc.Mapping[str, str] = <factory>, created_at: float = 0.0, completed_at: float | None = None) -> None",
      "ExperimentTracker": "class alphalab.experiment_tracking.tracker.ExperimentTracker(runs: alphalab.common.persistent_map.PersistentMap[str, alphalab.experiment_tracking.tracker.ExperimentRun] = <factory>) -> None",
      "ExperimentTrackingError": "class alphalab.experiment_tracking.exceptions.ExperimentTrackingError",
      "ExperimentTrackingInputError": "class alphalab.experiment_tracking.exceptions.ExperimentTrackingInputError",
      "ParamValue": "alias ParamValue",
      "RunStatus": "enum alphalab.experiment_tracking.tracker.RunStatus[RUNNING, COMPLETED, FAILED]",
      "best_metric_value": "function alphalab.experiment_tracking.comparison.best_metric_value(run: alphalab.experiment_tracking.tracker.ExperimentRun, metric_name: str, higher_is_better: bool = True) -> float | None",
      "best_run": "function alphalab.experiment_tracking.comparison.best_run(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, metric_name: str, higher_is_better: bool = True, use_best_value: bool = False) -> alphalab.experiment_tracking.tracker.ExperimentRun | None",
      "compare_runs": "function alphalab.experiment_tracking.comparison.compare_runs(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_ids: tuple[str, ...], metric_name: str) -> collections.abc.Mapping[str, float | None]",
      "complete_run": "function alphalab.experiment_tracking.tracker.complete_run(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_id: str, timestamp: float) -> alphalab.experiment_tracking.tracker.ExperimentTracker",
      "fail_run": "function alphalab.experiment_tracking.tracker.fail_run(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_id: str, timestamp: float) -> alphalab.experiment_tracking.tracker.ExperimentTracker",
      "latest_metric_value": "function alphalab.experiment_tracking.comparison.latest_metric_value(run: alphalab.experiment_tracking.tracker.ExperimentRun, metric_name: str) -> float | None",
      "lineage": "function alphalab.experiment_tracking.versioning.lineage(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_id: str) -> tuple[alphalab.experiment_tracking.tracker.ExperimentRun, ...]",
      "log_metric": "function alphalab.experiment_tracking.tracker.log_metric(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_id: str, metric_name: str, value: float) -> alphalab.experiment_tracking.tracker.ExperimentTracker",
      "log_metrics": "function alphalab.experiment_tracking.tracker.log_metrics(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_id: str, metrics: collections.abc.Mapping[str, float]) -> alphalab.experiment_tracking.tracker.ExperimentTracker",
      "new_version": "function alphalab.experiment_tracking.versioning.new_version(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, parent_run_id: str, parameters: collections.abc.Mapping[str, ParamValue], timestamp: float) -> tuple[alphalab.experiment_tracking.tracker.ExperimentTracker, str]",
      "start_run": "function alphalab.experiment_tracking.tracker.start_run(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, name: str, parameters: collections.abc.Mapping[str, ParamValue], timestamp: float, parent_run_id: str | None = None, tags: collections.abc.Mapping[str, str] | None = None) -> tuple[alphalab.experiment_tracking.tracker.ExperimentTracker, str]",
      "version_number": "function alphalab.experiment_tracking.versioning.version_number(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_id: str) -> int"
    },
    "alphalab.factor_library": {
      "Applicability": "class alphalab.factor_library.applicability.Applicability(verdict: 'Verdict', reason: 'str') -> None",
      "DELISTING_SET_SCHEME": "value builtins.str",
      "DecayProfile": "class alphalab.factor_library.decay.DecayProfile(factor_lineage: 'str', dataset_version: 'str | None', horizons: 'Mapping[int, InformationCoefficient]') -> None",
      "DelistingReturn": "class alphalab.factor_library.forward_returns.DelistingReturn(symbol: 'str', timestamp: 'float', terminal_return: 'float') -> None",
      "ExposureReport": "class alphalab.factor_library.exposure.ExposureReport(instants: 'int', by_asset: 'Mapping[str, float]', by_group: 'Mapping[str, float]', gross_by_group: 'Mapping[str, float]', gross_exposure: 'float', net_exposure: 'float', largest_group: 'str | None', concentration: 'float') -> None",
      "FACTOR_CATALOG": "value builtins.tuple",
      "FEATURE_KEY_SCHEME": "value builtins.str",
      "FEATURE_SERIES_KEY_SCHEME": "value builtins.str",
      "FIELD_AVAILABILITY": "value builtins.dict",
      "FIELD_READERS": "value builtins.dict",
      "FactorCategory": "enum alphalab.factor_library.catalog.FactorCategory[MOMENTUM, VALUE, QUALITY, CARRY, VOLATILITY, LIQUIDITY]",
      "FactorComputationError": "class alphalab.factor_library.exceptions.FactorComputationError",
      "FactorInputError": "class alphalab.factor_library.exceptions.FactorInputError",
      "FactorLibraryError": "class alphalab.factor_library.exceptions.FactorLibraryError",
      "FactorRanking": "class alphalab.factor_library.ranking.FactorRanking(panel: 'FeaturePanel', counts: 'Mapping[float, int]', method: 'RankMethod') -> None",
      "FactorResult": "class alphalab.factor_library.result.FactorResult(feature_id: str, version: int, asset_id: str | None, value: float, timestamp: float) -> None",
      "FactorSpec": "class alphalab.factor_library.catalog.FactorSpec(factor_id: str, category: alphalab.factor_library.catalog.FactorCategory, required_input: alphalab.factor_library.catalog.RequiredInput, description: str) -> None",
      "FactorTransform": "class alphalab.factor_library.panel.FactorTransform(operation: 'str', detail: 'str' = '') -> None",
      "FactorTurnover": "class alphalab.factor_library.turnover.FactorTurnover(convention: 'TurnoverConvention', mean_turnover: 'float', per_period: 'Mapping[float, float]', periods_measured: 'int', entries: 'int', exits: 'int') -> None",
      "FeatureDefinition": "class alphalab.factor_library.definition.FeatureDefinition(feature_id: 'str', kind: 'FeatureKind', source_field: 'FeatureField', window: 'int | None' = None, parameters: 'Mapping[str, float]' = <factory>, missing: 'MissingPolicy' = <MissingPolicy.SKIP: 2>, scope: 'FeatureScope' = <FeatureScope.TIME_SERIES: 1>) -> None",
      "FeatureField": "enum alphalab.factor_library.definition.FeatureField[OPEN, HIGH, LOW, CLOSE, VOLUME, PRICE, SIZE, BID, ASK, MID, OBSERVATION]",
      "FeatureKind": "enum alphalab.factor_library.definition.FeatureKind[RETURN, LOG_RETURN, ROLLING_MEAN, ROLLING_STD, ROLLING_MIN, ROLLING_MAX, ROLLING_SUM, EXPONENTIAL_MEAN, REALIZED_VOLATILITY, MOMENTUM, MEAN_REVERSION, ROLLING_ZSCORE, ROLLING_RATIO, VOLATILITY_REGIME, TIME_OF_DAY, DAY_OF_WEEK, CROSS_SECTIONAL_RANK, CROSS_SECTIONAL_ZSCORE, CROSS_SECTIONAL_DEMEAN]",
      "FeaturePanel": "class alphalab.factor_library.panel.FeaturePanel(definition: 'FeatureDefinition', dataset_version: 'str | None', timezone_name: 'str', rows: 'Mapping[float, Mapping[str, float]]', symbols: 'tuple[str, ...]', transforms: 'tuple[FactorTransform, ...]' = ()) -> None",
      "FeatureScope": "enum alphalab.factor_library.definition.FeatureScope[TIME_SERIES, CROSS_SECTIONAL]",
      "FeatureSeries": "class alphalab.factor_library.series.FeatureSeries(definition: 'FeatureDefinition', symbol: 'str', timestamps: 'tuple[float, ...]', values: 'tuple[float, ...]', dataset_version: 'str | None', timezone_name: 'str', observations: 'int', warmup_periods: 'int') -> None",
      "ForwardReturnPanel": "class alphalab.factor_library.forward_returns.ForwardReturnPanel(horizon: 'int', rows: 'Mapping[float, Mapping[str, float]]', dataset_version: 'str | None', timezone_name: 'str', symbols: 'tuple[str, ...]', unrealized_instants: 'int', lag: 'int', delisted_instants: 'int', unenterable_instants: 'int', delistings: 'tuple[DelistingReturn, ...]') -> None",
      "FrameRatio": "class alphalab.factor_library.knowledge.FrameRatio(frame: 'ObservationFrame', undefined: 'int') -> None",
      "FundamentalSnapshot": "class alphalab.factor_library.inputs.FundamentalSnapshot(asset_id: str, timestamp: float, price: decimal.Decimal, earnings_per_share: decimal.Decimal, book_value_per_share: decimal.Decimal, dividend_per_share: decimal.Decimal) -> None",
      "InformationCoefficient": "class alphalab.factor_library.ic.InformationCoefficient(horizon: 'int', factor_lineage: 'str', dataset_version: 'str | None', instants_measured: 'int', instants_skipped: 'int', observations: 'int', minimum_assets: 'int', mean_pearson: 'float | None', mean_rank: 'float | None', hit_rate: 'float | None', per_instant_rank: 'tuple[tuple[float, float], ...]', lag: 'int', newey_west_lag: 'int', rank_standard_error: 'float | None', rank_t_statistic: 'float | None') -> None",
      "KIND_REQUIREMENTS": "value builtins.mappingproxy",
      "KNOWLEDGE_FRAME_SCHEME": "value builtins.str",
      "KindRequirement": "class alphalab.factor_library.definition.KindRequirement(scope: 'FeatureScope', needs_window: 'bool', minimum_window: 'int' = 1, required_parameters: 'tuple[str, ...]' = (), permitted_parameters: 'tuple[str, ...]' = (), window_offset: 'int' = 0, reads_calendar: 'bool' = False) -> None",
      "KnowledgeFrame": "class alphalab.factor_library.knowledge.KnowledgeFrame(frame: 'ObservationFrame', frame_id: 'str', set_version: 'str', selection: 'str', clock: 'ResearchClock', visibility: 'VisibilityRule', policy: 'VintagePolicy', max_age_seconds: 'float | None', sources: 'Mapping[str, tuple[tuple[str, ...], ...]]', unknown: 'int', stale: 'int', unverified: 'int') -> None",
      "KnowledgeStep": "class alphalab.factor_library.knowledge.KnowledgeStep(known_at: 'float', value: 'float | None', observed_at: 'float | None', record_ids: 'tuple[str, ...]') -> None",
      "MAXIMUM_EXPOSURE_CONDITION": "value builtins.float",
      "MULTIPLICATIVE_CLASSES": "value builtins.frozenset",
      "MissingPolicy": "enum alphalab.factor_library.definition.MissingPolicy[REFUSE, SKIP]",
      "NeutralizationReport": "class alphalab.factor_library.neutralization.NeutralizationReport(panel: 'FeaturePanel', instants_neutralized: 'int', instants_skipped: 'int', mean_absolute_removed: 'float', refusals: 'tuple[tuple[float, str], ...]' = ()) -> None",
      "ObservationFrame": "class alphalab.factor_library.observations.ObservationFrame(source_field: 'FeatureField', series: 'Mapping[str, ObservationSeries]', timezone_name: 'str', dataset_version: 'str | None' = None) -> None",
      "ObservationSeries": "class alphalab.factor_library.observations.ObservationSeries(symbol: 'str', timestamps: 'tuple[float, ...]', values: 'tuple[float, ...]') -> None",
      "PriceSeries": "class alphalab.factor_library.inputs.PriceSeries(asset_id: str, bars: tuple[alphalab.market.bar.Bar, ...]) -> None",
      "RATIO_KINDS": "value builtins.frozenset",
      "RequiredInput": "enum alphalab.factor_library.catalog.RequiredInput[PRICE_SERIES, FUNDAMENTAL_SNAPSHOT]",
      "ResearchClock": "class alphalab.factor_library.knowledge.ResearchClock(instants: 'tuple[float, ...]', timezone_name: 'str', dataset_version: 'str | None') -> None",
      "SnapshotSpecification": "class alphalab.factor_library.fundamentals.SnapshotSpecification(earnings_per_share: 'FundamentalInput', book_equity: 'FundamentalInput', shares_outstanding: 'FundamentalInput', dividends_per_share: 'FundamentalInput') -> None",
      "TurnoverConvention": "enum alphalab.factor_library.turnover.TurnoverConvention[ABSOLUTE_CHANGE, ONE_WAY]",
      "Verdict": "enum alphalab.factor_library.applicability.Verdict[APPLIES, NO_SUCH_FIELD, NOT_RATIO_SCALED]",
      "align_prices": "function alphalab.factor_library.knowledge.align_prices(prices: 'ObservationFrame', knowledge: 'KnowledgeFrame') -> 'ObservationFrame'",
      "bucket_panel": "function alphalab.factor_library.ranking.bucket_panel(panel: 'FeaturePanel', buckets: 'int', tie_break: 'TieBreak' = <TieBreak.LOW: 1>) -> 'FeaturePanel'",
      "canonical_feature_key": "function alphalab.factor_library.definition.canonical_feature_key(definition: 'FeatureDefinition') -> 'str'",
      "canonical_series_key": "function alphalab.factor_library.series.canonical_series_key(feature_version: 'str', dataset_version: 'str', symbol: 'str', timezone_name: 'str') -> 'str'",
      "compute_carry": "function alphalab.factor_library.carry.compute_carry(fundamentals: alphalab.factor_library.inputs.FundamentalSnapshot, feature_id: str, version: int, timestamp: float) -> alphalab.factor_library.result.FactorResult",
      "compute_cross_section": "function alphalab.factor_library.primitives.compute_cross_section(definition: 'FeatureDefinition', values: 'Mapping[str, float]') -> 'Mapping[str, float]'",
      "compute_feature": "function alphalab.factor_library.compute.compute_feature(definition: 'FeatureDefinition', frame: 'ObservationFrame') -> 'tuple[FeatureSeries, ...]'",
      "compute_features": "function alphalab.factor_library.compute.compute_features(definitions: 'Sequence[FeatureDefinition]', frame: 'ObservationFrame') -> 'dict[str, tuple[FeatureSeries, ...]]'",
      "compute_liquidity": "function alphalab.factor_library.liquidity.compute_liquidity(prices: alphalab.factor_library.inputs.PriceSeries, feature_id: str, version: int, lookback_periods: int, timestamp: float) -> alphalab.factor_library.result.FactorResult",
      "compute_momentum": "function alphalab.factor_library.momentum.compute_momentum(prices: alphalab.factor_library.inputs.PriceSeries, feature_id: str, version: int, lookback_periods: int, timestamp: float) -> alphalab.factor_library.result.FactorResult",
      "compute_panel": "function alphalab.factor_library.compute.compute_panel(definition: 'FeatureDefinition', frame: 'ObservationFrame') -> 'FeaturePanel'",
      "compute_quality": "function alphalab.factor_library.quality.compute_quality(fundamentals: alphalab.factor_library.inputs.FundamentalSnapshot, feature_id: str, version: int, timestamp: float) -> alphalab.factor_library.result.FactorResult",
      "compute_time_series": "function alphalab.factor_library.primitives.compute_time_series(definition: 'FeatureDefinition', values: 'Sequence[float]', timestamps: 'Sequence[float]', timezone_name: 'str') -> 'tuple[float | None, ...]'",
      "compute_value": "function alphalab.factor_library.value.compute_value(fundamentals: alphalab.factor_library.inputs.FundamentalSnapshot, feature_id: str, version: int, timestamp: float) -> alphalab.factor_library.result.FactorResult",
      "compute_volatility": "function alphalab.factor_library.volatility.compute_volatility(prices: alphalab.factor_library.inputs.PriceSeries, feature_id: str, version: int, lookback_periods: int, timestamp: float, periods_per_year: int) -> alphalab.factor_library.result.FactorResult",
      "delisting_set_id": "function alphalab.factor_library.forward_returns.delisting_set_id(delistings: 'Sequence[DelistingReturn]') -> 'str'",
      "derive_feature_version": "function alphalab.factor_library.definition.derive_feature_version(definition: 'FeatureDefinition') -> 'str'",
      "derive_frame_id": "function alphalab.factor_library.knowledge.derive_frame_id(kind: 'str', set_version: 'str', selection: 'str', visibility: 'VisibilityRule', policy: 'VintagePolicy', max_age_seconds: 'float | None', clock: 'ResearchClock', subjects: 'Sequence[str]') -> 'str'",
      "derive_series_id": "function alphalab.factor_library.series.derive_series_id(feature_version: 'str', dataset_version: 'str', symbol: 'str', timezone_name: 'str') -> 'str'",
      "divide_frames": "function alphalab.factor_library.knowledge.divide_frames(numerator: 'ObservationFrame', denominator: 'ObservationFrame', *, name: 'str') -> 'FrameRatio'",
      "event_frame": "function alphalab.factor_library.knowledge.event_frame(view: 'ObservationView[InformationEvent]', event_type: 'str', measurement: 'str', clock: 'ResearchClock', subjects: 'Sequence[str]', *, max_age_seconds: 'float | None', policy: 'VintagePolicy') -> 'KnowledgeFrame'",
      "factor_decay": "function alphalab.factor_library.decay.factor_decay(factor: 'FeaturePanel', prices: 'ObservationFrame', horizons: 'Sequence[int]', minimum_assets: 'int' = 5, *, lag: 'int', delistings: 'Sequence[DelistingReturn]') -> 'DecayProfile'",
      "factor_exposure": "function alphalab.factor_library.exposure.factor_exposure(weights: 'Mapping[float, Mapping[str, float]]', groups: 'Mapping[str, str] | None' = None) -> 'ExposureReport'",
      "factor_turnover": "function alphalab.factor_library.turnover.factor_turnover(weights: 'Mapping[float, Mapping[str, float]]', convention: 'TurnoverConvention' = <TurnoverConvention.ONE_WAY: 2>) -> 'FactorTurnover'",
      "feature_applicability": "function alphalab.factor_library.applicability.feature_applicability(definition: 'FeatureDefinition', asset_class: 'DataAssetClass') -> 'Applicability'",
      "forward_returns": "function alphalab.factor_library.forward_returns.forward_returns(frame: 'ObservationFrame', horizon: 'int', *, lag: 'int', delistings: 'Sequence[DelistingReturn]') -> 'ForwardReturnPanel'",
      "fundamental_frame": "function alphalab.factor_library.fundamentals.fundamental_frame(view: 'ObservationView[FundamentalObservation]', spec: 'FundamentalInput', clock: 'ResearchClock', subjects: 'Sequence[str]', *, max_age_seconds: 'float | None', policy: 'VintagePolicy') -> 'KnowledgeFrame'",
      "fundamental_snapshot_as_of": "function alphalab.factor_library.fundamentals.fundamental_snapshot_as_of(view: 'ObservationView[FundamentalObservation]', subject: 'str', as_of: 'float', price: 'Decimal', price_unit: 'str', price_observed_at: 'float', policy: 'VintagePolicy', spec: 'SnapshotSpecification') -> 'FundamentalSnapshot'",
      "get_spec": "function alphalab.factor_library.catalog.get_spec(factor_id: str) -> alphalab.factor_library.catalog.FactorSpec | None",
      "information_coefficient": "function alphalab.factor_library.ic.information_coefficient(factor: 'FeaturePanel', returns: 'ForwardReturnPanel', minimum_assets: 'int' = 5) -> 'InformationCoefficient'",
      "loadings_from_panels": "function alphalab.factor_library.loadings.loadings_from_panels(panels: 'Mapping[str, FeaturePanel]', *, instant: 'float', source: 'str', asset_ids: 'Mapping[str, str] | None') -> 'FactorLoadings'",
      "neutralize_beta": "function alphalab.factor_library.neutralization.neutralize_beta(panel: 'FeaturePanel', exposures: 'Mapping[float, Mapping[str, float]]', minimum_assets: 'int' = 3) -> 'NeutralizationReport'",
      "neutralize_exposures": "function alphalab.factor_library.neutralization.neutralize_exposures(panel: 'FeaturePanel', exposures: 'Mapping[str, Mapping[float, Mapping[str, float]]]', *, minimum_assets: 'int', maximum_condition: 'float' = 1000000.0) -> 'NeutralizationReport'",
      "neutralize_group": "function alphalab.factor_library.neutralization.neutralize_group(panel: 'FeaturePanel', groups: 'Mapping[str, str]', minimum_group_size: 'int' = 2) -> 'NeutralizationReport'",
      "neutralize_mean": "function alphalab.factor_library.neutralization.neutralize_mean(panel: 'FeaturePanel', minimum_assets: 'int' = 2) -> 'NeutralizationReport'",
      "observation_frame": "function alphalab.factor_library.knowledge.observation_frame(view: 'ObservationView[ExternalObservation]', category: 'str', metric: 'str', clock: 'ResearchClock', subjects: 'Sequence[str]', *, max_age_seconds: 'float | None', policy: 'VintagePolicy') -> 'KnowledgeFrame'",
      "observations_from_dataset": "function alphalab.factor_library.observations.observations_from_dataset(dataset: 'Dataset', source_field: 'FeatureField') -> 'ObservationFrame'",
      "observations_from_price_series": "function alphalab.factor_library.observations.observations_from_price_series(prices: 'PriceSeries', source_field: 'FeatureField', timezone_name: 'str') -> 'ObservationFrame'",
      "observations_from_records": "function alphalab.factor_library.observations.observations_from_records(records: 'Sequence[CanonicalRecord]', source_field: 'FeatureField', timezone_name: 'str', dataset_version: 'str | None' = None) -> 'ObservationFrame'",
      "percentile_rank_panel": "function alphalab.factor_library.ranking.percentile_rank_panel(panel: 'FeaturePanel', method: 'RankMethod' = <RankMethod.AVERAGE: 1>, minimum_assets: 'int' = 2) -> 'FactorRanking'",
      "rank_panel": "function alphalab.factor_library.ranking.rank_panel(panel: 'FeaturePanel', method: 'RankMethod' = <RankMethod.AVERAGE: 1>, minimum_assets: 'int' = 2) -> 'FactorRanking'",
      "require_applicable": "function alphalab.factor_library.applicability.require_applicable(definition: 'FeatureDefinition', asset_class: 'DataAssetClass') -> 'None'",
      "sample_knowledge": "function alphalab.factor_library.knowledge.sample_knowledge(timelines: 'Mapping[str, Sequence[KnowledgeStep]]', instants: 'Sequence[float]', max_age_seconds: 'float | None') -> 'tuple[dict[str, ObservationSeries], dict[str, tuple[tuple[str, ...], ...]], int, int]'",
      "share_count_changes": "function alphalab.factor_library.fundamentals.share_count_changes(splits: 'Sequence[Split]', *, source: 'str', subjects: 'Mapping[str, str] | None' = None) -> 'tuple[ShareCountChange, ...]'",
      "to_factor_results": "function alphalab.factor_library.compute.to_factor_results(series: 'FeatureSeries', version: 'int') -> 'tuple[FactorResult, ...]'",
      "weights_from_buckets": "function alphalab.factor_library.turnover.weights_from_buckets(bucketed: 'FeaturePanel', buckets: 'int') -> 'dict[float, dict[str, float]]'"
    },
    "alphalab.feature_store": {
      "CacheHit": "class alphalab.feature_store.events.CacheHit(event_id: str, timestamp: float, feature_id: str, version: int) -> None",
      "CacheInvalidated": "class alphalab.feature_store.events.CacheInvalidated(event_id: str, timestamp: float, feature_id: str, version: int) -> None",
      "CacheMiss": "class alphalab.feature_store.events.CacheMiss(event_id: str, timestamp: float, feature_id: str, version: int) -> None",
      "FeatureCache": "class alphalab.feature_store.cache.FeatureCache(entries: alphalab.common.persistent_map.PersistentMap[str, alphalab.feature_store.value.FeatureValue] = <factory>, hits: int = 0, misses: int = 0) -> None",
      "FeatureDeprecated": "class alphalab.feature_store.events.FeatureDeprecated(event_id: str, timestamp: float, feature_id: str, version: int) -> None",
      "FeatureMetadata": "class alphalab.feature_store.metadata.FeatureMetadata(feature_id: str, name: str, version: int, feature_type: alphalab.feature_store.metadata.FeatureType, value_type: alphalab.feature_store.metadata.FeatureValueType, owner: str, description: str, asset_scoped: bool = True, depends_on: tuple[str, ...] = <factory>, tags: collections.abc.Mapping[str, str] = <factory>, created_at: float = 0.0) -> None",
      "FeatureNotFoundError": "class alphalab.feature_store.exceptions.FeatureNotFoundError",
      "FeatureRegistered": "class alphalab.feature_store.events.FeatureRegistered(event_id: str, timestamp: float, feature_id: str, version: int) -> None",
      "FeatureRegistry": "class alphalab.feature_store.registry.FeatureRegistry()",
      "FeatureStoreEngine": "class alphalab.feature_store.engine.FeatureStoreEngine()",
      "FeatureStoreError": "class alphalab.feature_store.exceptions.FeatureStoreError",
      "FeatureStoreEvent": "class alphalab.feature_store.events.FeatureStoreEvent(event_id: str, timestamp: float) -> None",
      "FeatureStoreState": "class alphalab.feature_store.state.FeatureStoreState(engine_id: str, features: alphalab.common.persistent_map.PersistentMap[str, alphalab.feature_store.metadata.FeatureMetadata] = <factory>, registered_feature_ids: alphalab.common.persistent_map.PersistentSet[str] = <factory>, deprecated_keys: alphalab.common.persistent_map.PersistentSet[str] = <factory>, values: alphalab.common.persistent_map.PersistentMap[str, alphalab.feature_store.value.FeatureValue] = <factory>, cache: alphalab.feature_store.cache.FeatureCache = <factory>, history: alphalab.common.append_log.AppendOnlyLog[alphalab.feature_store.decision.FeatureWriteDecision] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.feature_store.events.FeatureStoreEvent] = <factory>, statistics: alphalab.feature_store.state.FeatureStoreStatistics = <factory>, metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "FeatureStoreStatistics": "class alphalab.feature_store.state.FeatureStoreStatistics(total_registered: int = 0, total_deprecated: int = 0, total_values_written: int = 0, total_values_rejected: int = 0) -> None",
      "FeatureType": "enum alphalab.feature_store.metadata.FeatureType[PRICE, VOLUME, FUNDAMENTAL, ALTERNATIVE, CROSS_SECTIONAL, DERIVED]",
      "FeatureValidationError": "class alphalab.feature_store.exceptions.FeatureValidationError",
      "FeatureValue": "class alphalab.feature_store.value.FeatureValue(feature_id: str, version: int, asset_id: str | None, value: float | decimal.Decimal | int | bool | str, timestamp: float) -> None",
      "FeatureValueAdapter": "class alphalab.feature_store.adapter.FeatureValueAdapter()",
      "FeatureValueProtocol": "class alphalab.feature_store.protocol.FeatureValueProtocol(*args, **kwargs)",
      "FeatureValueRejected": "class alphalab.feature_store.events.FeatureValueRejected(event_id: str, timestamp: float, decision_id: str, feature_id: str, version: int, reason: str) -> None",
      "FeatureValueStore": "class alphalab.feature_store.store.FeatureValueStore()",
      "FeatureValueType": "enum alphalab.feature_store.metadata.FeatureValueType[FLOAT, DECIMAL, INTEGER, BOOLEAN, STRING]",
      "FeatureValueWritten": "class alphalab.feature_store.events.FeatureValueWritten(event_id: str, timestamp: float, decision_id: str, feature_id: str, version: int, asset_id: str | None) -> None",
      "FeatureViolation": "class alphalab.feature_store.violations.FeatureViolation(rule: str, description: str, severity: str, feature_id: str, current_value: str, allowed_value: str) -> None",
      "FeatureWriteDecision": "class alphalab.feature_store.decision.FeatureWriteDecision(decision_id: str, timestamp: float, feature_id: str, version: int, asset_id: str | None, approved: bool, reason: str, violations: tuple[alphalab.feature_store.violations.FeatureViolation, ...] = <factory>) -> None",
      "InvalidFeatureStateError": "class alphalab.feature_store.exceptions.InvalidFeatureStateError",
      "active_features": "function alphalab.feature_store.views.active_features(state: alphalab.feature_store.state.FeatureStoreState) -> collections.abc.Sequence[alphalab.feature_store.metadata.FeatureMetadata]",
      "cache_key": "function alphalab.feature_store.cache.cache_key(feature_id: str, version: int, asset_id: str | None) -> str",
      "check_asset_scope": "function alphalab.feature_store.checks.check_asset_scope(value: alphalab.feature_store.value.FeatureValue, metadata: alphalab.feature_store.metadata.FeatureMetadata) -> alphalab.feature_store.violations.FeatureViolation | None",
      "check_dependencies_registered": "function alphalab.feature_store.checks.check_dependencies_registered(metadata: alphalab.feature_store.metadata.FeatureMetadata, state: alphalab.feature_store.state.FeatureStoreState) -> alphalab.feature_store.violations.FeatureViolation | None",
      "check_feature_registered": "function alphalab.feature_store.checks.check_feature_registered(value: alphalab.feature_store.value.FeatureValue, state: alphalab.feature_store.state.FeatureStoreState) -> alphalab.feature_store.violations.FeatureViolation | None",
      "check_value_type": "function alphalab.feature_store.checks.check_value_type(value: alphalab.feature_store.value.FeatureValue, metadata: alphalab.feature_store.metadata.FeatureMetadata) -> alphalab.feature_store.violations.FeatureViolation | None",
      "deprecated_features": "function alphalab.feature_store.views.deprecated_features(state: alphalab.feature_store.state.FeatureStoreState) -> collections.abc.Sequence[alphalab.feature_store.metadata.FeatureMetadata]",
      "feature_statistics": "function alphalab.feature_store.views.feature_statistics(state: alphalab.feature_store.state.FeatureStoreState) -> alphalab.feature_store.state.FeatureStoreStatistics",
      "get_metadata": "function alphalab.feature_store.views.get_metadata(state: alphalab.feature_store.state.FeatureStoreState, feature_id: str, version: int) -> alphalab.feature_store.metadata.FeatureMetadata | None",
      "latest_value": "function alphalab.feature_store.views.latest_value(state: alphalab.feature_store.state.FeatureStoreState, feature_id: str, version: int, asset_id: str | None) -> alphalab.feature_store.value.FeatureValue | None",
      "list_features": "function alphalab.feature_store.views.list_features(state: alphalab.feature_store.state.FeatureStoreState) -> collections.abc.Sequence[alphalab.feature_store.metadata.FeatureMetadata]",
      "list_versions": "function alphalab.feature_store.views.list_versions(state: alphalab.feature_store.state.FeatureStoreState, feature_id: str) -> collections.abc.Sequence[int]",
      "validate_feature_metadata": "function alphalab.feature_store.validation.validate_feature_metadata(metadata: alphalab.feature_store.metadata.FeatureMetadata) -> None",
      "validate_lookup": "function alphalab.feature_store.validation.validate_lookup(state: alphalab.feature_store.state.FeatureStoreState, feature_id: str, version: int) -> None",
      "validate_registration": "function alphalab.feature_store.validation.validate_registration(state: alphalab.feature_store.state.FeatureStoreState, metadata: alphalab.feature_store.metadata.FeatureMetadata) -> None",
      "write_history": "function alphalab.feature_store.views.write_history(state: alphalab.feature_store.state.FeatureStoreState) -> collections.abc.Sequence[alphalab.feature_store.decision.FeatureWriteDecision]"
    },
    "alphalab.futures": {
      "AdjustmentMethod": "enum alphalab.futures.roll.AdjustmentMethod[UNADJUSTED, BACK_ADJUSTED, RATIO_ADJUSTED]",
      "CalendarSpread": "class alphalab.futures.spread.CalendarSpread(legs: tuple[alphalab.futures.spread.CalendarSpreadLeg, ...]) -> None",
      "CalendarSpreadLeg": "class alphalab.futures.spread.CalendarSpreadLeg(contract: alphalab.futures.contract.FutureContract, side: alphalab.core.enums.Side, quantity: int) -> None",
      "ContractChain": "class alphalab.futures.chain.ContractChain(root: 'str', contracts: 'tuple[FutureContract, ...]') -> None",
      "ContractMarginSpec": "class alphalab.futures.margin.ContractMarginSpec(contract_symbol: 'str', initial: 'Decimal', maintenance: 'Decimal', currency: 'str', as_of: 'float') -> None",
      "CurveShape": "enum alphalab.futures.curve.CurveShape[CONTANGO, BACKWARDATION, FLAT, MIXED]",
      "FutureContract": "class alphalab.futures.contract.FutureContract(underlying_asset_id: str, contract_month: float, expiry: float, multiplier: int, tick_size: decimal.Decimal, currency: str) -> None",
      "FuturesComputationError": "class alphalab.futures.exceptions.FuturesComputationError",
      "FuturesCurve": "class alphalab.futures.curve.FuturesCurve(underlying_asset_id: str, timestamp: float, points: tuple[alphalab.futures.curve.FuturesCurvePoint, ...]) -> None",
      "FuturesCurvePoint": "class alphalab.futures.curve.FuturesCurvePoint(contract_month: float, price: decimal.Decimal) -> None",
      "FuturesError": "class alphalab.futures.exceptions.FuturesError",
      "FuturesInputError": "class alphalab.futures.exceptions.FuturesInputError",
      "MarginPosture": "class alphalab.futures.margin.MarginPosture(contract_symbol: 'str', contracts: 'Decimal', initial: 'Decimal', maintenance: 'Decimal', currency: 'str', as_of: 'float') -> None",
      "RollEvent": "class alphalab.futures.chain.RollEvent(timestamp: 'float', outgoing: 'FutureContract', incoming: 'FutureContract', trigger: 'RollTrigger', reason: 'str') -> None",
      "RollPolicy": "class alphalab.futures.chain.RollPolicy(trigger: 'RollTrigger', offset_days: 'int | None' = None) -> None",
      "RollSegment": "class alphalab.futures.roll.RollSegment(contract: alphalab.futures.contract.FutureContract, bars: tuple[alphalab.market.bar.Bar, ...], outgoing_roll_price: decimal.Decimal | None = None, incoming_roll_price: decimal.Decimal | None = None) -> None",
      "RollTrigger": "enum alphalab.futures.chain.RollTrigger[CALENDAR_DAYS_BEFORE_EXPIRY, TRADING_DAYS_BEFORE_EXPIRY, VOLUME_CROSSOVER]",
      "SECONDS_PER_YEAR": "value builtins.float",
      "SessionCalendar": "class alphalab.futures.chain.SessionCalendar(*args, **kwargs)",
      "active_contract_at": "function alphalab.futures.chain.active_contract_at(chain: 'ContractChain', rolls: 'Sequence[RollEvent]', timestamp: 'float') -> 'FutureContract'",
      "build_continuous_series": "function alphalab.futures.roll.build_continuous_series(segments: tuple[alphalab.futures.roll.RollSegment, ...], method: alphalab.futures.roll.AdjustmentMethod) -> tuple[alphalab.market.bar.Bar, ...]",
      "compute_pnl": "function alphalab.futures.spread.compute_pnl(spread: alphalab.futures.spread.CalendarSpread, entry_prices: collections.abc.Mapping[str, decimal.Decimal], current_prices: collections.abc.Mapping[str, decimal.Decimal]) -> decimal.Decimal",
      "compute_spread_value": "function alphalab.futures.spread.compute_spread_value(spread: alphalab.futures.spread.CalendarSpread, prices: collections.abc.Mapping[str, decimal.Decimal]) -> decimal.Decimal",
      "continuous_segments": "function alphalab.futures.chain.continuous_segments(chain: 'ContractChain', rolls: 'Sequence[RollEvent]', observations: 'Mapping[str, Sequence[Bar]]') -> 'tuple[RollSegment, ...]'",
      "contract_tick_value": "function alphalab.futures.contract.contract_tick_value(contract: alphalab.futures.contract.FutureContract) -> alphalab.conventions.tick.TickValue",
      "curve_shape": "function alphalab.futures.curve.curve_shape(curve: alphalab.futures.curve.FuturesCurve) -> alphalab.futures.curve.CurveShape",
      "curve_slope": "function alphalab.futures.curve.curve_slope(curve: alphalab.futures.curve.FuturesCurve) -> decimal.Decimal",
      "futures_symbol": "function alphalab.futures.contract.futures_symbol(contract: alphalab.futures.contract.FutureContract) -> str",
      "is_backwardation": "function alphalab.futures.curve.is_backwardation(curve: alphalab.futures.curve.FuturesCurve) -> bool",
      "is_contango": "function alphalab.futures.curve.is_contango(curve: alphalab.futures.curve.FuturesCurve) -> bool",
      "open_future_position": "function alphalab.futures.contract.open_future_position(contract: alphalab.futures.contract.FutureContract, quantity: decimal.Decimal, price: decimal.Decimal, timestamp: float, *, minor_units: int | None = None) -> alphalab.portfolio.position.Position",
      "position_margin": "function alphalab.futures.margin.position_margin(contract: 'FutureContract', quantity: 'Decimal', specifications: 'Mapping[str, ContractMarginSpec]', as_of: 'float') -> 'MarginPosture'",
      "roll_schedule": "function alphalab.futures.chain.roll_schedule(chain: 'ContractChain', policy: 'RollPolicy', calendar: 'SessionCalendar | None' = None, observations: 'Mapping[str, Sequence[Bar]] | None' = None) -> 'tuple[RollEvent, ...]'",
      "roll_yield": "function alphalab.futures.curve.roll_yield(curve: alphalab.futures.curve.FuturesCurve, near_month: float, far_month: float) -> decimal.Decimal",
      "sorted_by_month": "function alphalab.futures.curve.sorted_by_month(curve: alphalab.futures.curve.FuturesCurve) -> tuple[alphalab.futures.curve.FuturesCurvePoint, ...]"
    },
    "alphalab.instrument": {
      "ALPHALAB_INSTRUMENT_NAMESPACE": "value uuid.UUID",
      "CASH_EQUITY": "value alphalab.conventions.economics.InstrumentEconomics",
      "ClassificationHistory": "class alphalab.instrument.classification.ClassificationHistory(entries: 'tuple[SectorClassification, ...]' = <factory>) -> None",
      "DatedAlias": "class alphalab.instrument.record.DatedAlias(provider: 'str', symbol: 'str', valid_from: 'float | None', valid_to: 'float | None') -> None",
      "DimensionClassification": "class alphalab.instrument.classification.DimensionClassification(label: 'str | None', source: 'str' = 'operator', as_of: 'float | None' = None) -> None",
      "DimensionHistory": "class alphalab.instrument.classification.DimensionHistory(entries: 'tuple[DimensionClassification, ...]' = <factory>) -> None",
      "INSTRUMENT_KEY_SCHEME": "value builtins.str",
      "InstrumentEconomics": "class alphalab.conventions.economics.InstrumentEconomics(multiplier: 'Decimal', settlement: 'SettlementModel', lot: 'LotSpecification | None' = None, minimum_notional: 'Decimal | None' = None, allows_negative_prices: 'bool' = False) -> None",
      "InstrumentError": "class alphalab.instrument.exceptions.InstrumentError",
      "InstrumentInputError": "class alphalab.instrument.exceptions.InstrumentInputError",
      "InstrumentRecord": "class alphalab.instrument.record.InstrumentRecord(symbol: 'str', asset_type: 'AssetType', exchange: 'str', currency: 'str', sector: 'str | None' = None, aliases: 'Mapping[str, str]' = <factory>, dated_aliases: 'tuple[DatedAlias, ...]' = (), economics: 'InstrumentEconomics | None' = None) -> None",
      "InstrumentRegistrationError": "class alphalab.instrument.exceptions.InstrumentRegistrationError",
      "InstrumentRegistry": "class alphalab.instrument.registry.InstrumentRegistry(instruments: 'PersistentMap[str, InstrumentRecord]' = <factory>, by_provider: 'PersistentMap[str, PersistentMap[str, str]]' = <factory>, classifications: 'PersistentMap[str, ClassificationHistory]' = <factory>, dated: 'PersistentMap[str, PersistentMap[str, tuple[tuple[DatedAlias, str], ...]]]' = <factory>, dimensions: 'PersistentMap[str, PersistentMap[str, DimensionHistory]]' = <factory>, members: 'PersistentMap[str, PersistentMap[str, PersistentMap[str, None]]] | None' = None) -> None",
      "OPERATOR": "value builtins.str",
      "SECTOR": "value builtins.str",
      "SectorClassification": "class alphalab.instrument.classification.SectorClassification(sector: 'str | None', source: 'str' = 'operator', as_of: 'float | None' = None) -> None",
      "SettlementModel": "enum alphalab.conventions.economics.SettlementModel[CASH_EQUITY, FUTURES_VARIATION, OPTION_PREMIUM, PERPETUAL]",
      "canonical_instrument_key": "function alphalab.instrument.identity.canonical_instrument_key(asset_type: 'AssetType', exchange: 'str', symbol: 'str', currency: 'str') -> 'str'",
      "classification_history": "function alphalab.instrument.registry.classification_history(registry: 'InstrumentRegistry', asset_id: 'str') -> 'ClassificationHistory'",
      "classification_of": "function alphalab.instrument.registry.classification_of(registry: 'InstrumentRegistry', asset_id: 'str') -> 'SectorClassification | None'",
      "classify_dimension": "function alphalab.instrument.registry.classify_dimension(registry: 'InstrumentRegistry', asset_id: 'str', dimension: 'str', label: 'str | None', source: 'str' = 'operator', as_of: 'float | None' = None) -> 'InstrumentRegistry'",
      "classify_dimensions": "function alphalab.instrument.registry.classify_dimensions(registry: 'InstrumentRegistry', dimension: 'str', labels: 'Mapping[str, str | None]', source: 'str' = 'operator', as_of: 'float | None' = None) -> 'InstrumentRegistry'",
      "classify_instrument": "function alphalab.instrument.registry.classify_instrument(registry: 'InstrumentRegistry', asset_id: 'str', sector: 'str | None', source: 'str' = 'operator', as_of: 'float | None' = None) -> 'InstrumentRegistry'",
      "classify_instruments": "function alphalab.instrument.registry.classify_instruments(registry: 'InstrumentRegistry', classifications: 'Mapping[str, str | None]', source: 'str' = 'operator', as_of: 'float | None' = None) -> 'InstrumentRegistry'",
      "derive_asset_id": "function alphalab.instrument.identity.derive_asset_id(asset_type: 'AssetType', exchange: 'str', symbol: 'str', currency: 'str') -> 'str'",
      "dimension_history": "function alphalab.instrument.registry.dimension_history(registry: 'InstrumentRegistry', asset_id: 'str', dimension: 'str') -> 'DimensionHistory'",
      "economics_for": "function alphalab.instrument.economics.economics_for(asset_type: 'AssetType', declared: 'InstrumentEconomics | None', name: 'str' = 'the instrument') -> 'InstrumentEconomics'",
      "get_instrument": "function alphalab.instrument.registry.get_instrument(registry: 'InstrumentRegistry', asset_id: 'str') -> 'InstrumentRecord'",
      "label_as_of": "function alphalab.instrument.registry.label_as_of(registry: 'InstrumentRegistry', asset_id: 'str', dimension: 'str', timestamp: 'float') -> 'str | None'",
      "normalize_dimension": "function alphalab.instrument.classification.normalize_dimension(value: 'str') -> 'str'",
      "normalize_key_field": "function alphalab.instrument.record.normalize_key_field(value: 'str', field_name: 'str') -> 'str'",
      "normalize_sector_label": "function alphalab.instrument.record.normalize_sector_label(value: 'str', field_name: 'str' = 'sector') -> 'str'",
      "register_alias": "function alphalab.instrument.registry.register_alias(registry: 'InstrumentRegistry', asset_id: 'str', provider: 'str', symbol: 'str') -> 'InstrumentRegistry'",
      "register_dated_alias": "function alphalab.instrument.registry.register_dated_alias(registry: 'InstrumentRegistry', asset_id: 'str', alias: 'DatedAlias') -> 'InstrumentRegistry'",
      "register_instrument": "function alphalab.instrument.registry.register_instrument(registry: 'InstrumentRegistry', record: 'InstrumentRecord') -> 'InstrumentRegistry'",
      "register_instruments": "function alphalab.instrument.registry.register_instruments(registry: 'InstrumentRegistry', records: 'Iterable[InstrumentRecord]') -> 'InstrumentRegistry'",
      "sector_as_of": "function alphalab.instrument.registry.sector_as_of(registry: 'InstrumentRegistry', asset_id: 'str', timestamp: 'float') -> 'str | None'"
    },
    "alphalab.instrument.snapshot": {
      "ClassificationRecord": "class alphalab.instrument.snapshot.ClassificationRecord(sector: 'str | None', source: 'str', as_of: 'float | None') -> None",
      "DatedAliasRecord": "class alphalab.instrument.snapshot.DatedAliasRecord(provider: 'str', symbol: 'str', valid_from: 'float | None', valid_to: 'float | None') -> None",
      "INSTRUMENT_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "INSTRUMENT_SNAPSHOT_SCHEMA": "value builtins.int",
      "InstrumentRegistryRecord": "class alphalab.instrument.snapshot.InstrumentRegistryRecord(symbol: 'str', asset_type: 'AssetType', exchange: 'str', currency: 'str', sector: 'str | None', aliases: 'Mapping[str, str]', classifications: 'tuple[ClassificationRecord, ...]', dated_aliases: 'tuple[DatedAliasRecord, ...]' = (), later_aliases: 'tuple[tuple[str, str], ...]' = (), later_dated_aliases: 'tuple[DatedAliasRecord, ...]' = (), economics: 'InstrumentEconomics | None' = None, dimensions: 'Mapping[str, tuple[DimensionRecord, ...]]' = <factory>) -> None",
      "InstrumentRegistrySnapshot": "class alphalab.instrument.snapshot.InstrumentRegistrySnapshot(instruments: 'tuple[InstrumentRegistryRecord, ...]', schema_version: 'int' = 3) -> None",
      "capture": "function alphalab.instrument.snapshot.capture(registry: 'InstrumentRegistry') -> 'InstrumentRegistrySnapshot'",
      "from_primitives": "function alphalab.instrument.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'InstrumentRegistrySnapshot'",
      "restore": "function alphalab.instrument.snapshot.restore(snapshot: 'InstrumentRegistrySnapshot') -> 'InstrumentRegistry'"
    },
    "alphalab.lifecycle": {
      "ADAPTIVE_SETTING_PREFIX": "value builtins.str",
      "AccountMirror": "class alphalab.lifecycle.reconciliation.AccountMirror(broker: 'BrokerState', mapping: 'ExternalOrderMap', symbols: 'SymbolMapping', children: 'ChildOrderBindings | None' = None) -> None",
      "AdaptiveReplayAssessment": "class alphalab.lifecycle.reproducibility.AdaptiveReplayAssessment(replay_id: 'str', record_verified: 'bool', rerun: 'RerunOutcome', detail: 'tuple[str, ...]', first_divergence: 'int | None') -> None",
      "AlignmentKey": "enum alphalab.lifecycle.comparison.AlignmentKey[ORDER_ID, ASSET_AND_TIME]",
      "ApprovalRecord": "class alphalab.lifecycle.governance.ApprovalRecord(name: 'str', version: 'int', environment: 'str', approver_id: 'str', timestamp: 'float', note: 'str' = '') -> None",
      "BROKER_STATUS_EQUIVALENTS": "value builtins.mappingproxy",
      "BrokerCapabilities": "class alphalab.lifecycle.specification.BrokerCapabilities(order_types: 'frozenset[OrderType]', time_in_force: 'frozenset[TimeInForce]', asset_classes: 'frozenset[AssetType]', short_selling: 'bool', fractional_quantities: 'bool') -> None",
      "BrokerRequirements": "class alphalab.lifecycle.specification.BrokerRequirements(order_types: 'frozenset[OrderType]', time_in_force: 'frozenset[TimeInForce]', asset_classes: 'frozenset[AssetType]', short_selling: 'bool', fractional_quantities: 'bool') -> None",
      "CAPITAL_SETTING_PREFIX": "value builtins.str",
      "CERTIFICATION_REPORT_SCHEME": "value builtins.str",
      "COMPONENT_EVIDENCE": "value builtins.str",
      "COMPONENT_MODEL": "value builtins.str",
      "COMPONENT_RUN": "value builtins.str",
      "COMPONENT_STRATEGY": "value builtins.str",
      "CapitalPlanIdentity": "class alphalab.lifecycle.fingerprint.CapitalPlanIdentity(*args, **kwargs)",
      "CapitalPolicy": "class alphalab.lifecycle.specification.CapitalPolicy(account_id: 'str', base_currency: 'str', allocated_capital: 'Decimal', settlement_currencies: 'tuple[str, ...]') -> None",
      "CertificationEvidence": "class alphalab.lifecycle.certification.CertificationEvidence(runs: 'tuple[BacktestResult, ...]' = (), repeated_runs: 'tuple[BacktestResult, ...]' = (), datasets: 'tuple[Dataset, ...]' = (), manifest: 'ReproducibilityManifest | None' = None, rerun: 'ReproducibilityManifest | None' = None, observations: 'tuple[RuntimeObservation, ...]' = (), measurements: 'tuple[ResourceMeasurement, ...]' = ()) -> None",
      "CertificationProperty": "enum alphalab.lifecycle.certification.CertificationProperty[DETERMINISTIC, REPRODUCIBLE, RISK_LIMITS, MAX_LEVERAGE, SUPPORTED_MARKETS, REQUIRED_DATA, RESOURCE_USAGE, RUNTIME_BEHAVIOR]",
      "CertificationReport": "class alphalab.lifecycle.certification.CertificationReport(report_id: 'str', fingerprint: 'str', specification_id: 'str', stage: 'StrategyLifecycleStage | None', specification_findings: 'tuple[str, ...]', assessments: 'tuple[PropertyAssessment, ...]') -> None",
      "CertificationStatus": "enum alphalab.lifecycle.certification.CertificationStatus[PASS, FAIL, NOT_ASSESSED, INSUFFICIENT_EVIDENCE]",
      "CodeIdentity": "class alphalab.lifecycle.fingerprint.CodeIdentity(package: 'str', version: 'str | None', entry_point: 'str', source_digest: 'str | None') -> None",
      "ComparisonEntry": "class alphalab.lifecycle.comparison.ComparisonEntry(metric: 'ComparisonMetric', key: 'str', outcome: 'ComparisonOutcome', expected: 'Decimal | None', observed: 'Decimal | None', detail: 'str' = '') -> None",
      "ComparisonMetric": "enum alphalab.lifecycle.comparison.ComparisonMetric[TRADE_QUANTITY, TRADE_PRICE, FILL_QUANTITY, FILL_PRICE, SLIPPAGE, EXECUTION_LATENCY, REALIZED_PNL, EXPOSURE]",
      "ComparisonOutcome": "enum alphalab.lifecycle.comparison.ComparisonOutcome[EXACT_MATCH, WITHIN_TOLERANCE, MATERIAL_DIFFERENCE, MISSING_EXPECTED, MISSING_OBSERVED, NOT_COMPARABLE]",
      "ComparisonSource": "enum alphalab.lifecycle.comparison.ComparisonSource[EXPECTED, PAPER, LIVE]",
      "ConstructionIdentity": "class alphalab.lifecycle.fingerprint.ConstructionIdentity(*args, **kwargs)",
      "DEPLOYABLE_STAGES": "value builtins.tuple",
      "DEPLOYMENT_SPECIFICATION_SCHEME": "value builtins.str",
      "DatasetAssumption": "class alphalab.lifecycle.specification.DatasetAssumption(role: 'str', dataset_version: 'str') -> None",
      "DatasetProvenanceView": "class alphalab.lifecycle.reproducibility.DatasetProvenanceView(*args, **kwargs)",
      "DependencyCompleteness": "enum alphalab.lifecycle.fingerprint.DependencyCompleteness[EXACT_CLOSURE, DIRECT_ONLY, UNDECLARED]",
      "DependencyManifest": "class alphalab.lifecycle.fingerprint.DependencyManifest(completeness: 'DependencyCompleteness', pins: 'tuple[DependencyPin, ...]') -> None",
      "DependencyPin": "class alphalab.lifecycle.fingerprint.DependencyPin(name: 'str', version: 'str', artifact_sha256: 'str | None' = None) -> None",
      "DeploymentRef": "class alphalab.lifecycle.identity.DeploymentRef(environment: 'str', release_name: 'str', release_version: 'int') -> None",
      "DeploymentSpecification": "class alphalab.lifecycle.specification.DeploymentSpecification(specification_id: 'str', strategy: 'StrategyVersionRef', parameters: 'Mapping[str, ParamValue]', datasets: 'tuple[DatasetAssumption, ...]', risk: 'RiskLimits', capital: 'CapitalPolicy', broker: 'BrokerRequirements', market: 'MarketRequirements', runtime: 'RuntimeRequirements') -> None",
      "EXECUTION_SETTING_PREFIX": "value builtins.str",
      "EngineBuild": "class alphalab.lifecycle.fingerprint.EngineBuild(source_digest: 'str', tz_database: 'str | None') -> None",
      "EngineIdentity": "class alphalab.lifecycle.fingerprint.EngineIdentity(name: 'str', version: 'str') -> None",
      "EnvironmentPortability": "class alphalab.lifecycle.portability.EnvironmentPortability(environment: 'str', mode: 'ExecutionMode', status: 'PortabilityStatus', checks: 'tuple[RequirementCheck, ...]') -> None",
      "ExecutionAlgorithmIdentity": "class alphalab.lifecycle.fingerprint.ExecutionAlgorithmIdentity(*args, **kwargs)",
      "ExecutionObservation": "class alphalab.lifecycle.health.ExecutionObservation(order_id: 'str', submitted_at: 'float | None', executed_at: 'float | None', rejected: 'bool' = False, detail: 'str' = '') -> None",
      "ExternalInput": "enum alphalab.lifecycle.reproducibility.ExternalInput[DATASET_BYTES, STRATEGY_CODE, DEPENDENCIES, ENGINE, LIVE_OBJECTS, NORMALIZATION_POLICY, CONTEXT_FACTORY, VENUE_EXECUTIONS, AUXILIARY_DATA]",
      "ExternalRequirement": "class alphalab.lifecycle.reproducibility.ExternalRequirement(input: 'ExternalInput', detail: 'str', recreatable: 'bool') -> None",
      "FillObservation": "class alphalab.lifecycle.comparison.FillObservation(key: 'str', asset_id: 'str', side: 'Side', quantity: 'Decimal', price: 'Decimal', commission: 'Decimal', filled_at: 'float', slippage: 'Decimal | None' = None, latency_seconds: 'Decimal | None' = None) -> None",
      "Governance": "class alphalab.lifecycle.governance.Governance(authority: 'PermissionAuthority', actor_id: 'str', approval_required_in: 'frozenset[str]' = <factory>) -> None",
      "GovernedAct": "class alphalab.lifecycle.governance.GovernedAct(action: 'str', subject: 'str', actor_id: 'str', timestamp: 'float', detail: 'str' = '') -> None",
      "HealthCategory": "enum alphalab.lifecycle.health.HealthCategory[STALE_DATA, ABNORMAL_EXECUTION, UNEXPECTED_POSITION, RISK_BREACH, HEARTBEAT_LOSS, BROKER_DISCONNECT, EXPECTED_STATE_DIVERGENCE]",
      "HealthFinding": "class alphalab.lifecycle.health.HealthFinding(category: 'HealthCategory', severity: 'HealthSeverity', subject: 'str', summary: 'str', observed_at: 'float', detail: 'Mapping[str, str]' = <factory>) -> None",
      "HealthReport": "class alphalab.lifecycle.health.HealthReport(specification_id: 'str', evaluated_at: 'float', findings: 'tuple[HealthFinding, ...]' = (), unevaluated: 'tuple[UnevaluatedCategory, ...]' = ()) -> None",
      "HealthSeverity": "enum alphalab.lifecycle.health.HealthSeverity[WARNING, BREACH]",
      "HealthStatus": "enum alphalab.lifecycle.health.HealthStatus[HEALTHY, UNKNOWN, DEGRADED, BREACHED]",
      "HealthWindowReport": "class alphalab.lifecycle.health.HealthWindowReport(specification_id: 'str', start: 'float', end: 'float', reports: 'tuple[HealthReport, ...]', occurrences: 'Mapping[HealthCategory, int]', persistent: 'tuple[HealthCategory, ...]', never_evaluated: 'tuple[HealthCategory, ...]') -> None",
      "INITIAL_STAGE": "value alphalab.lifecycle.progression.StrategyLifecycleStage",
      "LEGAL_PROGRESSION_TRANSITIONS": "value builtins.dict",
      "LIFECYCLE_PERMISSIONS": "value builtins.frozenset",
      "LifecycleError": "class alphalab.lifecycle.exceptions.LifecycleError",
      "LifecycleInputError": "class alphalab.lifecycle.exceptions.LifecycleInputError",
      "LifecyclePermissionError": "class alphalab.lifecycle.exceptions.LifecyclePermissionError",
      "LifecycleState": "class alphalab.lifecycle.state.LifecycleState(experiments: 'ExperimentTracker' = <factory>, models: 'ModelRegistry' = <factory>, strategies: 'StrategyVersionRegistry' = <factory>, deployments: 'DeploymentManager' = <factory>, evidence: 'PersistentMap[str, ValidationEvidence]' = <factory>, releases: 'PersistentMap[str, int]' = <factory>, approvals: 'AppendOnlyLog[ApprovalRecord]' = <factory>) -> None",
      "LifecycleTransitionError": "class alphalab.lifecycle.exceptions.LifecycleTransitionError",
      "LockFormat": "enum alphalab.lifecycle.lockfile.LockFormat[PIP_COMPILE, REQUIREMENTS, UV_LOCK, POETRY_LOCK]",
      "MONETARY_METRICS": "value builtins.tuple",
      "MarketAvailability": "class alphalab.lifecycle.specification.MarketAvailability(instruments: 'frozenset[str]', venues: 'frozenset[str]', calendar_ids: 'frozenset[str]', quote_currencies: 'frozenset[str]') -> None",
      "MarketRequirements": "class alphalab.lifecycle.specification.MarketRequirements(instruments: 'tuple[str, ...]', venues: 'tuple[str, ...]', calendar_ids: 'tuple[str, ...]', quote_currencies: 'tuple[str, ...]') -> None",
      "MeasurementBasis": "enum alphalab.lifecycle.certification.MeasurementBasis[COUNTED, MEASURED, ESTIMATED]",
      "MetricThreshold": "class alphalab.lifecycle.evidence.MetricThreshold(metric: 'str', minimum: 'float | None' = None, maximum: 'float | None' = None) -> None",
      "Mismatch": "class alphalab.lifecycle.reconciliation.Mismatch(category: 'MismatchCategory', key: 'str', expected: 'str | None', observed: 'str | None', reason: 'str', account: 'str | None' = None) -> None",
      "MismatchCategory": "enum alphalab.lifecycle.reconciliation.MismatchCategory[MISSING_EXPECTED_ORDER, UNEXPECTED_OBSERVED_ORDER, ORDER_QUANTITY_MISMATCH, ORDER_PRICE_MISMATCH, ORDER_STATUS_MISMATCH, MISSING_EXPECTED_FILL, UNEXPECTED_OBSERVED_FILL, FILL_QUANTITY_MISMATCH, EXECUTION_MISMATCH, POSITION_QUANTITY_MISMATCH, UNEXPECTED_POSITION, INSTRUMENT_MISMATCH, ACCOUNT_CASH_MISMATCH, LIFECYCLE_STATE_MISMATCH, ACCOUNT_ASSIGNMENT_MISMATCH]",
      "ModelRef": "class alphalab.lifecycle.identity.ModelRef(name: 'str', version: 'int') -> None",
      "NO_DEPENDENCIES": "value alphalab.lifecycle.fingerprint.DependencyManifest",
      "PAUSABLE_STAGES": "value builtins.tuple",
      "PERMISSION_APPROVE": "value builtins.str",
      "PERMISSION_DEPLOY": "value builtins.str",
      "PERMISSION_PROMOTE": "value builtins.str",
      "PERMISSION_RETIRE": "value builtins.str",
      "PERMISSION_ROLLBACK": "value builtins.str",
      "PORTABILITY_REPORT_SCHEME": "value builtins.str",
      "PORTFOLIO_SETTING_PREFIX": "value builtins.str",
      "PROGRESSION_MODEL_STAGES": "value builtins.dict",
      "PairComparison": "class alphalab.lifecycle.comparison.PairComparison(left: 'ComparisonSource', right: 'ComparisonSource', entries: 'tuple[ComparisonEntry, ...]' = ()) -> None",
      "PermissionAuthority": "class alphalab.lifecycle.governance.PermissionAuthority(*args, **kwargs)",
      "PortabilityReport": "class alphalab.lifecycle.portability.PortabilityReport(report_id: 'str', fingerprint: 'str', specification_id: 'str', environments: 'tuple[EnvironmentPortability, ...]') -> None",
      "PortabilityRequirement": "enum alphalab.lifecycle.portability.PortabilityRequirement[STRATEGY_LOGIC, EXECUTION, MARKET, DATA, CONTRACTS, RUNTIME, RISK, CAPITAL]",
      "PortabilityStatus": "enum alphalab.lifecycle.portability.PortabilityStatus[PORTABLE, NOT_PORTABLE, INSUFFICIENT_EVIDENCE]",
      "PropertyAssessment": "class alphalab.lifecycle.certification.PropertyAssessment(claim: 'CertificationProperty', status: 'CertificationStatus', methodology: 'str', evidence: 'Mapping[str, str]', findings: 'tuple[str, ...]', limitations: 'tuple[str, ...]') -> None",
      "REPRODUCIBILITY_MANIFEST_SCHEME": "value builtins.str",
      "RERUN_DIFFERENCE_LIMIT": "value builtins.int",
      "ROUTING_SETTING_PREFIX": "value builtins.str",
      "ReconciliationTolerances": "class alphalab.lifecycle.reconciliation.ReconciliationTolerances(order_quantity: 'Tolerance', order_price: 'Tolerance', fill_quantity: 'Tolerance', fill_price: 'Tolerance', commission: 'Tolerance', position_quantity: 'Tolerance', cash: 'Tolerance') -> None",
      "ReproducibilityAssessment": "class alphalab.lifecycle.reproducibility.ReproducibilityAssessment(manifest_id: 'str', identity_verified: 'bool', gaps: 'tuple[str, ...]', rerun: 'RerunOutcome', rerun_detail: 'tuple[str, ...]', external_requirements: 'tuple[ExternalRequirement, ...]', findings: 'tuple[str, ...]') -> None",
      "ReproducibilityManifest": "class alphalab.lifecycle.reproducibility.ReproducibilityManifest(manifest_id: 'str', kind: 'ResultKind', result_id: 'str', dataset_version: 'str', dataset_content_hash: 'str', configuration: 'str', configuration_id: 'str', seed: 'int | None', seed_role: 'SeedRole', engine: 'EngineIdentity', fingerprint: 'StrategyFingerprint | None', build: 'EngineBuild | None' = None) -> None",
      "RequirementCheck": "class alphalab.lifecycle.portability.RequirementCheck(requirement: 'PortabilityRequirement', outcome: 'RequirementOutcome', detail: 'str', blockers: 'tuple[str, ...]' = ()) -> None",
      "RequirementOutcome": "enum alphalab.lifecycle.portability.RequirementOutcome[SATISFIED, BLOCKED, NOT_VERIFIED, NOT_APPLICABLE]",
      "RerunOutcome": "enum alphalab.lifecycle.reproducibility.RerunOutcome[NOT_ATTEMPTED, REPRODUCED, DIVERGED, INPUTS_DIFFER]",
      "RerunReport": "class alphalab.lifecycle.rerun.RerunReport(manifest_id: 'str', outcome: 'RerunOutcome', detail: 'tuple[str, ...]', assessment: 'ReproducibilityAssessment | None', rerun_manifest: 'ReproducibilityManifest | None', differences: 'tuple[str, ...]') -> None",
      "ResearchConfiguration": "class alphalab.lifecycle.fingerprint.ResearchConfiguration(settings: 'Mapping[str, str]', study_id: 'str | None' = None) -> None",
      "ResourceBudget": "class alphalab.lifecycle.certification.ResourceBudget(metric: 'ResourceMetric', maximum: 'Decimal') -> None",
      "ResourceMeasurement": "class alphalab.lifecycle.certification.ResourceMeasurement(metric: 'ResourceMetric', value: 'Decimal', basis: 'MeasurementBasis', method: 'str', environment: 'str') -> None",
      "ResourceMetric": "enum alphalab.lifecycle.certification.ResourceMetric[RECORDS_PROCESSED, ORDERS_SUBMITTED, FILLS, CPU_SECONDS, WALL_CLOCK_SECONDS, PEAK_MEMORY_BYTES]",
      "ResultKind": "enum alphalab.lifecycle.reproducibility.ResultKind[RUN, STUDY]",
      "RoutingPolicyIdentity": "class alphalab.lifecycle.fingerprint.RoutingPolicyIdentity(*args, **kwargs)",
      "RunAuthorization": "class alphalab.lifecycle.execution.RunAuthorization(plan: 'RunPlan', strategy_id: 'str') -> None",
      "RunDigest": "class alphalab.lifecycle.reproducibility.RunDigest(result_id: 'str', configuration: 'str', configuration_id: 'str', mode: 'ExecutionMode', seed: 'int | None', dataset_id: 'str | None', strategy_ids: 'tuple[str, ...]', live_objects: 'tuple[str, ...]') -> None",
      "RunObservations": "class alphalab.lifecycle.comparison.RunObservations(source: 'ComparisonSource', trades: 'tuple[TradeObservation, ...] | None' = None, fills: 'tuple[FillObservation, ...] | None' = None, realized_pnl: 'CurrencyAmounts | None' = None, exposure: 'CurrencyAmounts | None' = None) -> None",
      "RunPlan": "class alphalab.lifecycle.execution.RunPlan(environment: 'str', version: 'StrategyVersion', reference: 'StrategyVersionRef', evidence: 'ValidationEvidence | None', deployed_by: 'str', deployed_at: 'float') -> None",
      "RuntimeObservation": "class alphalab.lifecycle.health.RuntimeObservation(observed_at: 'float', last_market_data_at: 'float | None' = None, last_heartbeat_at: 'float | None' = None, broker_connection: 'ConnectionStatus | None' = None, executions: 'tuple[ExecutionObservation, ...] | None' = None, observed_positions: 'Mapping[str, Decimal] | None' = None, expected_positions: 'Mapping[str, Decimal] | None' = None, risk_violations: 'tuple[RiskViolation, ...] | None' = None, state_expectations: 'tuple[StateExpectation, ...] | None' = None) -> None",
      "RuntimeProfile": "class alphalab.lifecycle.portability.RuntimeProfile(data_delay_seconds: 'float', heartbeat_interval_seconds: 'float', execution_latency_seconds: 'float') -> None",
      "RuntimeRequirements": "class alphalab.lifecycle.specification.RuntimeRequirements(max_data_staleness_seconds: 'float', max_heartbeat_silence_seconds: 'float', max_execution_latency_seconds: 'float', position_tolerance: 'Tolerance') -> None",
      "STAGEABLE_MODEL_STAGES": "value builtins.tuple",
      "STRATEGY_FINGERPRINT_SCHEME": "value builtins.str",
      "STRATEGY_SOURCE_SCHEME": "value builtins.str",
      "SeedRole": "enum alphalab.lifecycle.reproducibility.SeedRole[IDENTIFIER_STREAM, STOCHASTIC_STEPS, ABSENT]",
      "SourceBytesView": "class alphalab.lifecycle.reproducibility.SourceBytesView(*args, **kwargs)",
      "StageTransition": "class alphalab.lifecycle.progression.StageTransition(from_stage: 'StrategyLifecycleStage', to_stage: 'StrategyLifecycleStage', reason: 'str', timestamp: 'float', actor_id: 'str' = '') -> None",
      "StateExpectation": "class alphalab.lifecycle.health.StateExpectation(name: 'str', expected: 'str | None', observed: 'str | None') -> None",
      "StateReconciliation": "class alphalab.lifecycle.reconciliation.StateReconciliation(mismatches: 'tuple[Mismatch, ...]' = (), unreconciled: 'tuple[UnreconciledArea, ...]' = (), compared_orders: 'int' = 0, compared_fills: 'int' = 0, compared_positions: 'int' = 0, unassigned: 'tuple[str, ...]' = ()) -> None",
      "StaticPermissions": "class alphalab.lifecycle.governance.StaticPermissions(grants: 'Mapping[str, frozenset[str]]') -> None",
      "StrategyFingerprint": "class alphalab.lifecycle.fingerprint.StrategyFingerprint(fingerprint: 'str', name: 'str', strategy_id: 'str', code: 'CodeIdentity', dependencies: 'DependencyManifest', parameters: 'Mapping[str, ParamValue]', research: 'ResearchConfiguration', engine: 'EngineIdentity') -> None",
      "StrategyLifecycleStage": "enum alphalab.lifecycle.progression.StrategyLifecycleStage[RESEARCH, BACKTEST, VALIDATION, PAPER, PRODUCTION_CANDIDATE, LIVE, PAUSED, ARCHIVED]",
      "StrategyProgression": "class alphalab.lifecycle.progression.StrategyProgression(reference: 'StrategyVersionRef', stage: 'StrategyLifecycleStage', history: 'AppendOnlyLog[StageTransition]') -> None",
      "StrategyPromotionRecord": "class alphalab.lifecycle.strategy_version.StrategyPromotionRecord(name: 'str', version: 'int', from_stage: 'ModelStage', to_stage: 'ModelStage', reason: 'str', timestamp: 'float', actor_id: 'str' = '') -> None",
      "StrategyVersion": "class alphalab.lifecycle.strategy_version.StrategyVersion(name: 'str', version: 'int', definition: 'StrategyDefinition', stage: 'ModelStage', model: 'ModelRef | None' = None, run_id: 'str | None' = None, evidence_id: 'str | None' = None, policy_id: 'str | None' = None, created_at: 'float' = 0.0, tags: 'Mapping[str, str]' = <factory>) -> None",
      "StrategyVersionRef": "class alphalab.lifecycle.identity.StrategyVersionRef(name: 'str', version: 'int') -> None",
      "StrategyVersionRegistry": "class alphalab.lifecycle.strategy_version.StrategyVersionRegistry(versions: 'PersistentMap[str, PersistentMap[int, StrategyVersion]]' = <factory>, promotions: 'AppendOnlyLog[StrategyPromotionRecord]' = <factory>) -> None",
      "StudyIdentity": "class alphalab.lifecycle.fingerprint.StudyIdentity(*args, **kwargs)",
      "SymbolMapping": "class alphalab.lifecycle.reconciliation.SymbolMapping(mapping: 'Mapping[str, str]' = <factory>, assume_identity: 'bool' = False) -> None",
      "TargetEnvironment": "class alphalab.lifecycle.portability.TargetEnvironment(name: 'str', mode: 'ExecutionMode', broker: 'BrokerCapabilities', market: 'MarketAvailability', datasets: 'frozenset[str] | None' = None, conventions: 'Mapping[str, MarketConvention] | None' = None, runtime: 'RuntimeProfile | None' = None, max_leverage: 'Decimal | None' = None, account_currencies: 'frozenset[str] | None' = None) -> None",
      "ThreeWayComparison": "class alphalab.lifecycle.comparison.ThreeWayComparison(expected_vs_paper: 'PairComparison', expected_vs_live: 'PairComparison', paper_vs_live: 'PairComparison') -> None",
      "Tolerance": "class alphalab.lifecycle.tolerance.Tolerance(absolute: 'Decimal | None' = None, relative: 'Decimal | None' = None) -> None",
      "ToleranceOutcome": "enum alphalab.lifecycle.tolerance.ToleranceOutcome[EXACT, WITHIN_TOLERANCE, MATERIAL]",
      "TradeObservation": "class alphalab.lifecycle.comparison.TradeObservation(key: 'str', asset_id: 'str', side: 'Side', quantity: 'Decimal', price: 'Decimal', executed_at: 'float') -> None",
      "UNDECLARED_DEPENDENCIES": "value alphalab.lifecycle.fingerprint.DependencyManifest",
      "UnevaluatedCategory": "class alphalab.lifecycle.health.UnevaluatedCategory(category: 'HealthCategory', reason: 'str') -> None",
      "UnreconciledArea": "class alphalab.lifecycle.reconciliation.UnreconciledArea(area: 'str', reason: 'str') -> None",
      "ValidationEvidence": "class alphalab.lifecycle.evidence.ValidationEvidence(evidence_id: 'str', method: 'ValidationMethod', subject: 'str', dataset_id: 'str', metrics: 'Mapping[str, float]' = <factory>, seed: 'int | None' = None, produced_at: 'float' = 0.0, source_id: 'str' = '') -> None",
      "ValidationMethod": "enum alphalab.lifecycle.evidence.ValidationMethod[BACKTEST, RESEARCH, EXTERNAL, STUDY]",
      "ValidationOutcome": "class alphalab.lifecycle.evidence.ValidationOutcome(policy_id: 'str', evidence_id: 'str', passed: 'bool', failures: 'tuple[str, ...]' = ()) -> None",
      "ValidationPolicy": "class alphalab.lifecycle.evidence.ValidationPolicy(policy_id: 'str', thresholds: 'tuple[MetricThreshold, ...]' = (), required_method: 'ValidationMethod | None' = None) -> None",
      "VersionedDataset": "class alphalab.lifecycle.reproducibility.VersionedDataset(*args, **kwargs)",
      "active_model_version": "function alphalab.lifecycle.views.active_model_version(state: 'LifecycleState', environment: 'str') -> 'ModelRef | None'",
      "active_strategy_version": "function alphalab.lifecycle.views.active_strategy_version(state: 'LifecycleState', environment: 'str') -> 'StrategyVersion | None'",
      "advance_progression": "function alphalab.lifecycle.progression.advance_progression(progression: 'StrategyProgression', target: 'StrategyLifecycleStage', reason: 'str', timestamp: 'float', actor_id: 'str' = '') -> 'StrategyProgression'",
      "approval_for": "function alphalab.lifecycle.governance.approval_for(approvals: 'Iterable[ApprovalRecord]', name: 'str', version: 'int', environment: 'str', deployer_id: 'str') -> 'ApprovalRecord'",
      "approvals_for": "function alphalab.lifecycle.governance.approvals_for(approvals: 'Iterable[ApprovalRecord]', name: 'str', version: 'int', environment: 'str') -> 'tuple[ApprovalRecord, ...]'",
      "approvals_of": "function alphalab.lifecycle.views.approvals_of(state: 'LifecycleState', name: 'str', version: 'int', environment: 'str') -> 'tuple[ApprovalRecord, ...]'",
      "approve_deployment": "function alphalab.lifecycle.promotion.approve_deployment(state: 'LifecycleState', governance: 'Governance', name: 'str', version: 'int', environment: 'str', timestamp: 'float', note: 'str' = '') -> 'LifecycleState'",
      "archive_progression": "function alphalab.lifecycle.progression.archive_progression(progression: 'StrategyProgression', reason: 'str', timestamp: 'float', actor_id: 'str' = '') -> 'StrategyProgression'",
      "assess_adaptive_replay": "function alphalab.lifecycle.reproducibility.assess_adaptive_replay(original: 'AdaptiveReplay', rerun: 'AdaptiveReplay | None' = None) -> 'AdaptiveReplayAssessment'",
      "assess_reproducibility": "function alphalab.lifecycle.reproducibility.assess_reproducibility(manifest: 'ReproducibilityManifest', rerun: 'ReproducibilityManifest | None' = None) -> 'ReproducibilityAssessment'",
      "authorize_run": "function alphalab.lifecycle.execution.authorize_run(state: 'LifecycleState', environment: 'str', reference: 'StrategyVersionRef', strategy_id: 'str') -> 'RunAuthorization'",
      "begin_progression": "function alphalab.lifecycle.progression.begin_progression(reference: 'StrategyVersionRef') -> 'StrategyProgression'",
      "broker_capabilities_from": "function alphalab.lifecycle.specification.broker_capabilities_from(declaration: 'CapabilityDeclaration', *, listing_venues: 'frozenset[str]', asset_classes: 'frozenset[AssetType]', account_id: 'str') -> 'BrokerCapabilities'",
      "build_evidence": "function alphalab.lifecycle.evidence.build_evidence(method: 'ValidationMethod', subject: 'str', dataset_id: 'str', metrics: 'Mapping[str, float]', produced_at: 'float', seed: 'int | None' = None, source_id: 'str' = '') -> 'ValidationEvidence'",
      "build_fingerprint": "function alphalab.lifecycle.fingerprint.build_fingerprint(name: 'str', strategy_id: 'str', code: 'CodeIdentity', dependencies: 'DependencyManifest', parameters: 'Mapping[str, ParamValue]', research: 'ResearchConfiguration', engine: 'EngineIdentity') -> 'StrategyFingerprint'",
      "build_specification": "function alphalab.lifecycle.specification.build_specification(strategy: 'StrategyVersionRef', parameters: 'Mapping[str, ParamValue]', datasets: 'Sequence[DatasetAssumption]', risk: 'RiskLimits', capital: 'CapitalPolicy', broker: 'BrokerRequirements', market: 'MarketRequirements', runtime: 'RuntimeRequirements') -> 'DeploymentSpecification'",
      "canonical_fingerprint_key": "function alphalab.lifecycle.fingerprint.canonical_fingerprint_key(name: 'str', strategy_id: 'str', code: 'CodeIdentity', dependencies: 'DependencyManifest', parameters: 'Mapping[str, ParamValue]', research: 'ResearchConfiguration', engine: 'EngineIdentity') -> 'str'",
      "canonical_manifest_key": "function alphalab.lifecycle.reproducibility.canonical_manifest_key(kind: 'ResultKind', result_id: 'str', dataset_version: 'str', dataset_content_hash: 'str', configuration_id: 'str', seed: 'int | None', seed_role: 'SeedRole', engine: 'EngineIdentity', fingerprint: 'str | None', build: 'EngineBuild | None' = None) -> 'str'",
      "certify_strategy": "function alphalab.lifecycle.certification.certify_strategy(fingerprint: 'StrategyFingerprint', specification: 'DeploymentSpecification', evidence: 'CertificationEvidence', budgets: 'Sequence[ResourceBudget]' = (), progression: 'StrategyProgression | None' = None) -> 'CertificationReport'",
      "code_identity_for": "function alphalab.lifecycle.fingerprint.code_identity_for(registration: 'StrategyRegistration', package: 'str', version: 'str | None', sources: 'Mapping[str, bytes] | None') -> 'CodeIdentity'",
      "compare_expected_paper_live": "function alphalab.lifecycle.comparison.compare_expected_paper_live(expected: 'RunObservations', paper: 'RunObservations', live: 'RunObservations', tolerances: 'Mapping[ComparisonMetric, Tolerance]') -> 'ThreeWayComparison'",
      "compare_runs": "function alphalab.lifecycle.comparison.compare_runs(left: 'RunObservations', right: 'RunObservations', tolerances: 'Mapping[ComparisonMetric, Tolerance]') -> 'PairComparison'",
      "dataset_assumption_from": "function alphalab.lifecycle.specification.dataset_assumption_from(dataset: 'Dataset', role: 'str') -> 'DatasetAssumption'",
      "deploy_strategy_version": "function alphalab.lifecycle.deployment.deploy_strategy_version(state: 'LifecycleState', governance: 'Governance', name: 'str', version: 'int', environment: 'str', timestamp: 'float', deployed_by: 'str' = '', notes: 'str' = '') -> 'tuple[LifecycleState, DeploymentRef]'",
      "derive_manifest_id": "function alphalab.lifecycle.reproducibility.derive_manifest_id(kind: 'ResultKind', result_id: 'str', dataset_version: 'str', dataset_content_hash: 'str', configuration_id: 'str', seed: 'int | None', seed_role: 'SeedRole', engine: 'EngineIdentity', fingerprint: 'str | None', build: 'EngineBuild | None' = None) -> 'str'",
      "derive_strategy_fingerprint": "function alphalab.lifecycle.fingerprint.derive_strategy_fingerprint(name: 'str', strategy_id: 'str', code: 'CodeIdentity', dependencies: 'DependencyManifest', parameters: 'Mapping[str, ParamValue]', research: 'ResearchConfiguration', engine: 'EngineIdentity') -> 'str'",
      "differing_parameters": "function alphalab.lifecycle.fingerprint.differing_parameters(left: 'Mapping[str, ParamValue]', right: 'Mapping[str, ParamValue]') -> 'tuple[str, ...]'",
      "digest_run": "function alphalab.lifecycle.reproducibility.digest_run(result: 'BacktestResult') -> 'RunDigest'",
      "engine_source_digest": "function alphalab.lifecycle.environment.engine_source_digest() -> 'str'",
      "environments_running": "function alphalab.lifecycle.views.environments_running(state: 'LifecycleState', name: 'str', version: 'int') -> 'tuple[str, ...]'",
      "evaluate_health": "function alphalab.lifecycle.health.evaluate_health(specification: 'DeploymentSpecification', observation: 'RuntimeObservation') -> 'HealthReport'",
      "evaluate_health_window": "function alphalab.lifecycle.health.evaluate_health_window(specification: 'DeploymentSpecification', observations: 'Sequence[RuntimeObservation]', *, as_of: 'float', window_seconds: 'float') -> 'HealthWindowReport'",
      "evaluate_policy": "function alphalab.lifecycle.evidence.evaluate_policy(policy: 'ValidationPolicy', evidence: 'ValidationEvidence') -> 'ValidationOutcome'",
      "evaluate_portability": "function alphalab.lifecycle.portability.evaluate_portability(fingerprint: 'StrategyFingerprint', specification: 'DeploymentSpecification', environments: 'Sequence[TargetEnvironment]', conventions: 'Mapping[str, MarketConvention] | None' = None) -> 'PortabilityReport'",
      "evidence_for": "function alphalab.lifecycle.views.evidence_for(state: 'LifecycleState', name: 'str', version: 'int') -> 'ValidationEvidence | None'",
      "evidence_from_backtest": "function alphalab.lifecycle.evidence.evidence_from_backtest(result: 'BacktestResult', subject: 'str', produced_at: 'float') -> 'ValidationEvidence'",
      "evidence_from_research": "function alphalab.lifecycle.evidence.evidence_from_research(state: 'ResearchState', subject: 'str', dataset_id: 'str', produced_at: 'float') -> 'ValidationEvidence'",
      "evidence_from_study": "function alphalab.lifecycle.evidence.evidence_from_study(result: 'StudyResult', subject: 'str', produced_at: 'float') -> 'ValidationEvidence'",
      "evidence_id_for": "function alphalab.lifecycle.evidence.evidence_id_for(method: 'ValidationMethod', subject: 'str', dataset_id: 'str', seed: 'int | None', metrics: 'Mapping[str, float]') -> 'str'",
      "external_requirements": "function alphalab.lifecycle.reproducibility.external_requirements(manifest: 'ReproducibilityManifest') -> 'tuple[ExternalRequirement, ...]'",
      "fingerprint_differences": "function alphalab.lifecycle.fingerprint.fingerprint_differences(left: 'StrategyFingerprint', right: 'StrategyFingerprint') -> 'tuple[str, ...]'",
      "fingerprint_for_version": "function alphalab.lifecycle.fingerprint.fingerprint_for_version(version: 'StrategyVersion', code: 'CodeIdentity', dependencies: 'DependencyManifest', research: 'ResearchConfiguration', engine: 'EngineIdentity') -> 'StrategyFingerprint'",
      "get_strategy_version": "function alphalab.lifecycle.strategy_version.get_strategy_version(registry: 'StrategyVersionRegistry', name: 'str', version: 'int') -> 'StrategyVersion'",
      "governance_log": "function alphalab.lifecycle.views.governance_log(state: 'LifecycleState') -> 'tuple[GovernedAct, ...]'",
      "illegal_progression_move": "function alphalab.lifecycle.progression.illegal_progression_move(progression: 'StrategyProgression', target: 'StrategyLifecycleStage') -> 'str | None'",
      "latest_strategy_version": "function alphalab.lifecycle.strategy_version.latest_strategy_version(registry: 'StrategyVersionRegistry', name: 'str') -> 'StrategyVersion'",
      "list_strategy_versions": "function alphalab.lifecycle.strategy_version.list_strategy_versions(registry: 'StrategyVersionRegistry', name: 'str') -> 'tuple[StrategyVersion, ...]'",
      "live_environments": "function alphalab.lifecycle.views.live_environments(state: 'LifecycleState') -> 'tuple[str, ...]'",
      "manifest_for_run": "function alphalab.lifecycle.reproducibility.manifest_for_run(result: 'BacktestResult', dataset: 'VersionedDataset', fingerprint: 'StrategyFingerprint', engine: 'EngineIdentity', *, build: 'EngineBuild | None') -> 'ReproducibilityManifest'",
      "manifest_for_study": "function alphalab.lifecycle.reproducibility.manifest_for_study(result: 'StudyResult', dataset: 'VersionedDataset', engine: 'EngineIdentity', fingerprint: 'StrategyFingerprint | None' = None, *, build: 'EngineBuild | None') -> 'ReproducibilityManifest'",
      "manifest_gaps": "function alphalab.lifecycle.reproducibility.manifest_gaps(manifest: 'ReproducibilityManifest') -> 'tuple[str, ...]'",
      "normalize_distribution_name": "function alphalab.lifecycle.fingerprint.normalize_distribution_name(name: 'str') -> 'str'",
      "observation_from_live_run": "function alphalab.lifecycle.health.observation_from_live_run(state: 'object', observed_at: 'float', last_market_data_at: 'float | None' = None, expected_positions: 'Mapping[str, Decimal] | None' = None, risk_violations: 'tuple[RiskViolation, ...] | None' = None, state_expectations: 'tuple[StateExpectation, ...] | None' = None, submitted_at: 'Mapping[str, float] | None' = None) -> 'RuntimeObservation'",
      "observations_from_backtest": "function alphalab.lifecycle.comparison.observations_from_backtest(result: 'BacktestResult', source: 'ComparisonSource', alignment: 'AlignmentKey', exposure: 'CurrencyAmounts | None' = None, submitted_at: 'Mapping[str, float] | None' = None) -> 'RunObservations'",
      "observations_from_broker": "function alphalab.lifecycle.comparison.observations_from_broker(state: 'BrokerState', source: 'ComparisonSource', alignment: 'AlignmentKey', realized_pnl: 'CurrencyAmounts | None' = None, exposure: 'CurrencyAmounts | None' = None, submitted_at: 'Mapping[str, float] | None' = None) -> 'RunObservations'",
      "parse_ref": "function alphalab.lifecycle.identity.parse_ref(reference: 'str') -> 'tuple[str, int]'",
      "pause_progression": "function alphalab.lifecycle.progression.pause_progression(progression: 'StrategyProgression', reason: 'str', timestamp: 'float', actor_id: 'str' = '') -> 'StrategyProgression'",
      "progression_conflicts": "function alphalab.lifecycle.progression.progression_conflicts(progression: 'StrategyProgression', version: 'StrategyVersion') -> 'tuple[str, ...]'",
      "promote_strategy_version": "function alphalab.lifecycle.promotion.promote_strategy_version(state: 'LifecycleState', governance: 'Governance', name: 'str', version: 'int', policy: 'ValidationPolicy', evidence_id: 'str', timestamp: 'float') -> 'LifecycleState'",
      "read_lock_file": "function alphalab.lifecycle.lockfile.read_lock_file(text: 'str', lock_format: 'LockFormat', *, exclude: 'Iterable[str]' = ()) -> 'DependencyManifest'",
      "reconcile_accounts": "function alphalab.lifecycle.reconciliation.reconcile_accounts(pipeline: 'ExecutionPipelineState', accounts: 'Mapping[str, AccountMirror]', assignment: 'Mapping[str, str]', tolerances: 'ReconciliationTolerances', *, cash_by_currency: 'Mapping[str, Tolerance] | None' = None) -> 'StateReconciliation'",
      "reconcile_execution_state": "function alphalab.lifecycle.reconciliation.reconcile_execution_state(pipeline: 'ExecutionPipelineState', broker: 'BrokerState', mapping: 'ExternalOrderMap', symbols: 'SymbolMapping', tolerances: 'ReconciliationTolerances', *, children: 'ChildOrderBindings | None' = None) -> 'StateReconciliation'",
      "record_evidence": "function alphalab.lifecycle.promotion.record_evidence(state: 'LifecycleState', evidence: 'ValidationEvidence') -> 'LifecycleState'",
      "record_stage_change": "function alphalab.lifecycle.promotion.record_stage_change(state: 'LifecycleState', strategy: 'StrategyVersion', to_stage: 'ModelStage', reason: 'str', timestamp: 'float', evidence_id: 'str | None' = None, policy_id: 'str | None' = None, actor_id: 'str' = '') -> 'LifecycleState'",
      "register_model_version": "function alphalab.lifecycle.registration.register_model_version(state: 'LifecycleState', name: 'str', model: 'object', timestamp: 'float', run_id: 'str | None' = None, metrics: 'Mapping[str, float] | None' = None, parameters: 'Mapping[str, ParamValue] | None' = None, tags: 'Mapping[str, str] | None' = None, artifact: 'ArtifactRef | None' = None) -> 'tuple[LifecycleState, ModelRef]'",
      "register_strategy": "function alphalab.lifecycle.registration.register_strategy(state: 'LifecycleState', name: 'str', definition: 'StrategyDefinition', timestamp: 'float', model: 'ModelRef | None' = None, run_id: 'str | None' = None, tags: 'Mapping[str, str] | None' = None) -> 'tuple[LifecycleState, StrategyVersionRef]'",
      "register_strategy_version": "function alphalab.lifecycle.strategy_version.register_strategy_version(registry: 'StrategyVersionRegistry', name: 'str', definition: 'StrategyDefinition', timestamp: 'float', model: 'ModelRef | None' = None, run_id: 'str | None' = None, tags: 'Mapping[str, str] | None' = None) -> 'tuple[StrategyVersionRegistry, StrategyVersion]'",
      "release_manifest": "function alphalab.lifecycle.deployment.release_manifest(strategy: 'StrategyVersion') -> 'tuple[dict[str, str], dict[str, str]]'",
      "replace_strategy_version": "function alphalab.lifecycle.strategy_version.replace_strategy_version(registry: 'StrategyVersionRegistry', updated: 'StrategyVersion') -> 'StrategyVersionRegistry'",
      "rerun_from_manifest": "function alphalab.lifecycle.rerun.rerun_from_manifest(manifest: 'ReproducibilityManifest', run: 'Callable[[], BacktestResult]', *, dataset: 'VersionedDataset', fingerprint: 'StrategyFingerprint', engine: 'EngineIdentity', build: 'EngineBuild | None', original: 'BacktestResult | None' = None) -> 'RerunReport'",
      "research_configuration": "function alphalab.lifecycle.fingerprint.research_configuration(settings: 'Mapping[str, str]', study_id: 'str | None' = None) -> 'ResearchConfiguration'",
      "research_configuration_for_study": "function alphalab.lifecycle.fingerprint.research_configuration_for_study(study: 'StudyIdentity', settings: 'Mapping[str, str] | None' = None) -> 'ResearchConfiguration'",
      "research_configuration_with_adaptive": "function alphalab.lifecycle.fingerprint.research_configuration_with_adaptive(settings: 'Mapping[str, str]', adaptive: 'Sequence[tuple[AdaptiveConfiguration, AdaptiveState]]', study: 'StudyIdentity | None' = None) -> 'ResearchConfiguration'",
      "research_configuration_with_execution": "function alphalab.lifecycle.fingerprint.research_configuration_with_execution(settings: 'Mapping[str, str]', *, algorithms: 'Mapping[str, ExecutionAlgorithmIdentity]', routing: 'Mapping[str, RoutingPolicyIdentity]', study: 'StudyIdentity | None') -> 'ResearchConfiguration'",
      "research_configuration_with_portfolio": "function alphalab.lifecycle.fingerprint.research_configuration_with_portfolio(settings: 'Mapping[str, str]', *, constructions: 'Mapping[str, ConstructionIdentity]', capital: 'Mapping[str, CapitalPlanIdentity]', study: 'StudyIdentity | None') -> 'ResearchConfiguration'",
      "resource_counts": "function alphalab.lifecycle.certification.resource_counts(result: 'BacktestResult') -> 'tuple[ResourceMeasurement, ...]'",
      "resume_progression": "function alphalab.lifecycle.progression.resume_progression(progression: 'StrategyProgression', reason: 'str', timestamp: 'float', actor_id: 'str' = '') -> 'StrategyProgression'",
      "resume_target": "function alphalab.lifecycle.progression.resume_target(progression: 'StrategyProgression') -> 'StrategyLifecycleStage | None'",
      "retire_strategy_version": "function alphalab.lifecycle.promotion.retire_strategy_version(state: 'LifecycleState', governance: 'Governance', name: 'str', version: 'int', timestamp: 'float', reason: 'str' = 'retired') -> 'LifecycleState'",
      "rollback_environment": "function alphalab.lifecycle.deployment.rollback_environment(state: 'LifecycleState', governance: 'Governance', environment: 'str', timestamp: 'float', deployed_by: 'str' = '', notes: 'str' = '') -> 'tuple[LifecycleState, DeploymentRef]'",
      "run_plan": "function alphalab.lifecycle.execution.run_plan(state: 'LifecycleState', environment: 'str') -> 'RunPlan'",
      "running_build": "function alphalab.lifecycle.environment.running_build() -> 'EngineBuild'",
      "running_engine": "function alphalab.lifecycle.fingerprint.running_engine() -> 'EngineIdentity'",
      "source_digest": "function alphalab.lifecycle.fingerprint.source_digest(sources: 'Mapping[str, bytes]') -> 'str'",
      "source_tree_digest": "function alphalab.lifecycle.environment.source_tree_digest(root: 'Path') -> 'str'",
      "specification_for_version": "function alphalab.lifecycle.specification.specification_for_version(version: 'StrategyVersion', datasets: 'Sequence[DatasetAssumption]', risk: 'RiskLimits', capital: 'CapitalPolicy', broker: 'BrokerRequirements', market: 'MarketRequirements', runtime: 'RuntimeRequirements') -> 'DeploymentSpecification'",
      "specification_id_for": "function alphalab.lifecycle.specification.specification_id_for(strategy: 'StrategyVersionRef', parameters: 'Mapping[str, ParamValue]', datasets: 'Sequence[DatasetAssumption]', risk: 'RiskLimits', capital: 'CapitalPolicy', broker: 'BrokerRequirements', market: 'MarketRequirements', runtime: 'RuntimeRequirements') -> 'str'",
      "strategy_names": "function alphalab.lifecycle.strategy_version.strategy_names(registry: 'StrategyVersionRegistry') -> 'tuple[str, ...]'",
      "tz_database_version": "function alphalab.lifecycle.environment.tz_database_version() -> 'str | None'",
      "unmet_broker_requirements": "function alphalab.lifecycle.specification.unmet_broker_requirements(requirements: 'BrokerRequirements', capabilities: 'BrokerCapabilities') -> 'tuple[str, ...]'",
      "unmet_market_requirements": "function alphalab.lifecycle.specification.unmet_market_requirements(requirements: 'MarketRequirements', availability: 'MarketAvailability') -> 'tuple[str, ...]'",
      "validate_specification": "function alphalab.lifecycle.specification.validate_specification(specification: 'DeploymentSpecification') -> 'tuple[str, ...]'",
      "validate_strategy_version": "function alphalab.lifecycle.promotion.validate_strategy_version(state: 'LifecycleState', name: 'str', version: 'int', policy: 'ValidationPolicy', evidence_id: 'str') -> 'ValidationOutcome'",
      "verify_certification_report": "function alphalab.lifecycle.certification.verify_certification_report(report: 'CertificationReport') -> 'bool'",
      "verify_evidence_id": "function alphalab.lifecycle.evidence.verify_evidence_id(evidence: 'ValidationEvidence') -> 'bool'",
      "verify_fingerprint": "function alphalab.lifecycle.fingerprint.verify_fingerprint(fingerprint: 'StrategyFingerprint') -> 'bool'",
      "verify_manifest": "function alphalab.lifecycle.reproducibility.verify_manifest(manifest: 'ReproducibilityManifest') -> 'bool'",
      "verify_portability_report": "function alphalab.lifecycle.portability.verify_portability_report(report: 'PortabilityReport') -> 'bool'",
      "verify_specification_id": "function alphalab.lifecycle.specification.verify_specification_id(specification: 'DeploymentSpecification') -> 'bool'"
    },
    "alphalab.lifecycle.snapshot": {
      "LIFECYCLE_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "LIFECYCLE_SNAPSHOT_SCHEMA": "value builtins.int",
      "LifecycleSnapshot": "class alphalab.lifecycle.snapshot.LifecycleSnapshot(runs: 'tuple[ExperimentRun, ...]', model_versions: 'tuple[ModelVersionRecord, ...]', model_promotions: 'tuple[PromotionRecord, ...]', production: 'Mapping[str, int]', production_line: 'Mapping[str, tuple[int, ...]]', strategy_versions: 'tuple[StrategyVersion, ...]', strategy_promotions: 'tuple[StrategyPromotionRecord, ...]', release_packages: 'tuple[ReleasePackage, ...]', deployments: 'tuple[DeploymentRecord, ...]', evidence: 'tuple[ValidationEvidence, ...]', releases: 'Mapping[str, int]', approvals: 'tuple[ApprovalRecord, ...]' = (), schema_version: 'int' = 2) -> None",
      "ModelVersionRecord": "class alphalab.lifecycle.snapshot.ModelVersionRecord(name: 'str', version: 'int', model_type: 'str', stage: 'ModelStage', metrics: 'Mapping[str, float]', parameters: 'Mapping[str, Any]', tags: 'Mapping[str, str]', run_id: 'str | None', created_at: 'float', deployment: 'DeploymentMetadata | None', artifact: 'ArtifactRef | None') -> None",
      "capture": "function alphalab.lifecycle.snapshot.capture(state: 'LifecycleState') -> 'LifecycleSnapshot'",
      "from_primitives": "function alphalab.lifecycle.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'LifecycleSnapshot'",
      "restore": "function alphalab.lifecycle.snapshot.restore(snapshot: 'LifecycleSnapshot', models: 'Mapping[str, object]') -> 'LifecycleState'"
    },
    "alphalab.macro": {
      "Bond": "class alphalab.macro.bond.Bond(face: 'Decimal', coupon_rate: 'float', frequency: 'Compounding', issue_date: 'date', maturity: 'date', day_count: 'DayCount', currency: 'str') -> None",
      "CashFlow": "class alphalab.macro.bond.CashFlow(payment_date: 'date', amount: 'Decimal', is_principal: 'bool') -> None",
      "CentralBankEvent": "class alphalab.macro.central_bank.CentralBankEvent(bank_id: str, event_date: float, action: alphalab.macro.enums.PolicyAction, rate_before: decimal.Decimal, rate_after: decimal.Decimal, next_meeting_date: float | None = None) -> None",
      "Frequency": "enum alphalab.macro.enums.Frequency[DAILY, WEEKLY, MONTHLY, QUARTERLY, ANNUAL]",
      "IndicatorMetadata": "class alphalab.macro.indicator.IndicatorMetadata(indicator_id: str, name: str, country: str, frequency: alphalab.macro.enums.Frequency, units: str, seasonally_adjusted: bool = True) -> None",
      "IndicatorObservation": "class alphalab.macro.indicator.IndicatorObservation(indicator_id: str, reference_period: float, release_date: float, value: decimal.Decimal, is_revision: bool = False, consensus_estimate: decimal.Decimal | None = None) -> None",
      "MacroComputationError": "class alphalab.macro.exceptions.MacroComputationError",
      "MacroError": "class alphalab.macro.exceptions.MacroError",
      "MacroInputError": "class alphalab.macro.exceptions.MacroInputError",
      "PolicyAction": "enum alphalab.macro.enums.PolicyAction[HIKE, CUT, HOLD]",
      "YieldCurve": "class alphalab.macro.yield_curve.YieldCurve(country: str, currency: str, timestamp: float, points: tuple[alphalab.macro.yield_curve.YieldCurvePoint, ...]) -> None",
      "YieldCurvePoint": "class alphalab.macro.yield_curve.YieldCurvePoint(tenor_years: decimal.Decimal, yield_rate: decimal.Decimal) -> None",
      "accrued_interest": "function alphalab.macro.bond.accrued_interest(bond: 'Bond', settlement: 'date') -> 'Decimal'",
      "cash_flows": "function alphalab.macro.bond.cash_flows(bond: 'Bond') -> 'tuple[CashFlow, ...]'",
      "clean_price": "function alphalab.macro.bond.clean_price(bond: 'Bond', yield_rate: 'float', settlement: 'date') -> 'Decimal'",
      "convexity": "function alphalab.macro.bond.convexity(bond: 'Bond', yield_rate: 'float', settlement: 'date') -> 'float'",
      "dirty_price": "function alphalab.macro.bond.dirty_price(bond: 'Bond', yield_rate: 'float', settlement: 'date') -> 'Decimal'",
      "discount_factor_at": "function alphalab.macro.yield_curve.discount_factor_at(curve: alphalab.macro.yield_curve.YieldCurve, tenor_years: decimal.Decimal, compounding: alphalab.conventions.rates.Compounding) -> float | None",
      "gdp_growth_rate": "function alphalab.macro.gdp.gdp_growth_rate(current_gdp: decimal.Decimal, prior_gdp: decimal.Decimal) -> decimal.Decimal",
      "is_inverted": "function alphalab.macro.yield_curve.is_inverted(curve: alphalab.macro.yield_curve.YieldCurve, short_tenor_years: decimal.Decimal = Decimal('2'), long_tenor_years: decimal.Decimal = Decimal('10')) -> bool | None",
      "known_as_of": "function alphalab.macro.indicator.known_as_of(observations: tuple[alphalab.macro.indicator.IndicatorObservation, ...], as_of: float) -> alphalab.macro.indicator.IndicatorObservation | None",
      "macaulay_duration": "function alphalab.macro.bond.macaulay_duration(bond: 'Bond', yield_rate: 'float', settlement: 'date') -> 'float'",
      "modified_duration": "function alphalab.macro.bond.modified_duration(bond: 'Bond', yield_rate: 'float', settlement: 'date') -> 'float'",
      "rate_change_bps": "function alphalab.macro.central_bank.rate_change_bps(event: alphalab.macro.central_bank.CentralBankEvent) -> int",
      "real_gdp": "function alphalab.macro.gdp.real_gdp(nominal_gdp: decimal.Decimal, gdp_deflator_index: decimal.Decimal) -> decimal.Decimal",
      "real_interest_rate_approx": "function alphalab.macro.inflation.real_interest_rate_approx(nominal_rate: decimal.Decimal, inflation_rate: decimal.Decimal) -> decimal.Decimal",
      "real_interest_rate_exact": "function alphalab.macro.inflation.real_interest_rate_exact(nominal_rate: decimal.Decimal, inflation_rate: decimal.Decimal) -> decimal.Decimal",
      "sorted_by_tenor": "function alphalab.macro.yield_curve.sorted_by_tenor(curve: alphalab.macro.yield_curve.YieldCurve) -> tuple[alphalab.macro.yield_curve.YieldCurvePoint, ...]",
      "spread": "function alphalab.macro.yield_curve.spread(curve: alphalab.macro.yield_curve.YieldCurve, short_tenor_years: decimal.Decimal, long_tenor_years: decimal.Decimal) -> decimal.Decimal | None",
      "surprise": "function alphalab.macro.indicator.surprise(observation: alphalab.macro.indicator.IndicatorObservation) -> decimal.Decimal | None",
      "three_month_ten_year_spread": "function alphalab.macro.yield_curve.three_month_ten_year_spread(curve: alphalab.macro.yield_curve.YieldCurve) -> decimal.Decimal | None",
      "two_year_ten_year_spread": "function alphalab.macro.yield_curve.two_year_ten_year_spread(curve: alphalab.macro.yield_curve.YieldCurve) -> decimal.Decimal | None",
      "yield_at_tenor": "function alphalab.macro.yield_curve.yield_at_tenor(curve: alphalab.macro.yield_curve.YieldCurve, tenor_years: decimal.Decimal) -> decimal.Decimal | None",
      "yield_from_clean_price": "function alphalab.macro.bond.yield_from_clean_price(bond: 'Bond', price: 'Decimal', settlement: 'date') -> 'float'"
    },
    "alphalab.market": {
      "Bar": "class alphalab.market.bar.Bar(asset_id: 'str', timestamp: 'float', open: 'Decimal', high: 'Decimal', low: 'Decimal', close: 'Decimal', volume: 'Decimal', vwap: 'Decimal | None', trade_count: 'int | None', timeframe: 'TimeFrame') -> None",
      "BarClosed": "class alphalab.market.events.BarClosed(event_id: str, timestamp: float, bar: alphalab.market.bar.Bar) -> None",
      "BarHistoryProvider": "class alphalab.market.provider.BarHistoryProvider(*args, **kwargs)",
      "BookUpdated": "class alphalab.market.events.BookUpdated(event_id: str, timestamp: float, snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> None",
      "IdentityResolution": "alias alphalab.instrument.registry.InstrumentRegistry | alphalab.market.normalization.UnresolvedIdentity",
      "InstrumentResolutionError": "class alphalab.market.exceptions.InstrumentResolutionError",
      "MarketDataError": "class alphalab.market.exceptions.MarketDataError",
      "MarketDataSource": "class alphalab.market.source.MarketDataSource(*args, **kwargs)",
      "MarketEngine": "class alphalab.market.engine.MarketEngine()",
      "MarketEvent": "class alphalab.market.events.MarketEvent(event_id: str, timestamp: float) -> None",
      "MarketInput": "alias alphalab.market.quote.Quote | alphalab.market.bar.Bar | alphalab.market.tick.Tick",
      "MarketRecord": "class alphalab.market.record.MarketRecord(event_id: 'str', timestamp: 'float', payload: 'MarketInput') -> None",
      "MarketState": "class alphalab.market.state.MarketState(latest_quotes: alphalab.common.persistent_map.PersistentMap[str, alphalab.market.quote.Quote] = <factory>, latest_books: alphalab.common.persistent_map.PersistentMap[str, alphalab.market.snapshot.OrderBookSnapshot] = <factory>, latest_ticks: alphalab.common.persistent_map.PersistentMap[str, alphalab.market.tick.Tick] = <factory>, latest_bars: alphalab.common.persistent_map.PersistentMap[str, alphalab.market.bar.Bar] = <factory>, history: alphalab.common.append_log.AppendOnlyLog[alphalab.market.events.MarketEvent] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.market.events.MarketEvent] = <factory>) -> None",
      "MarketValidationError": "class alphalab.market.exceptions.MarketValidationError",
      "NormalizationPolicy": "class alphalab.market.normalization.NormalizationPolicy(venue: 'str' = 'UNKNOWN', currency: 'str | None' = None, timeframe: 'TimeFrame | None' = None, identity: 'IdentityResolution' = UnresolvedIdentity(symbols=SymbolMap(mapping={})), provider: 'str' = '', bar_stamp: 'BarStamp | None' = None) -> None",
      "OrderBookLevel": "class alphalab.market.level.OrderBookLevel(price: decimal.Decimal, size: decimal.Decimal, orders: int) -> None",
      "OrderBookSnapshot": "class alphalab.market.snapshot.OrderBookSnapshot(asset_id: str, timestamp: float, bids: tuple[alphalab.market.level.OrderBookLevel, ...], asks: tuple[alphalab.market.level.OrderBookLevel, ...], sequence: int) -> None",
      "OrderingGuarantee": "enum alphalab.market.source.OrderingGuarantee[CHRONOLOGICAL, UNORDERED]",
      "ProviderHistorySource": "class alphalab.market.provider.ProviderHistorySource(source_id: 'str', _records: 'tuple[MarketRecord, ...]', ordering: 'OrderingGuarantee' = <OrderingGuarantee.CHRONOLOGICAL: 1>) -> None",
      "Quote": "class alphalab.market.quote.Quote(asset_id: str, timestamp: float, bid: decimal.Decimal, ask: decimal.Decimal, bid_size: decimal.Decimal, ask_size: decimal.Decimal, venue: str, currency: str) -> None",
      "QuoteReceived": "class alphalab.market.events.QuoteReceived(event_id: str, timestamp: float, quote: alphalab.market.quote.Quote) -> None",
      "SequenceSource": "class alphalab.market.source.SequenceSource(source_id: 'str', _records: 'tuple[MarketRecord, ...]', ordering: 'OrderingGuarantee' = <OrderingGuarantee.CHRONOLOGICAL: 1>) -> None",
      "SnapshotCreated": "class alphalab.market.events.SnapshotCreated(event_id: str, timestamp: float, snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> None",
      "SymbolMap": "class alphalab.market.normalization.SymbolMap(mapping: 'Mapping[str, str]' = <factory>) -> None",
      "Tick": "class alphalab.market.tick.Tick(asset_id: str, timestamp: float, price: decimal.Decimal, quantity: decimal.Decimal, trade_id: str, venue: str, currency: str, aggressor: alphalab.data.feed.TradeAggressor | None = None) -> None",
      "TickReceived": "class alphalab.market.events.TickReceived(event_id: str, timestamp: float, tick: alphalab.market.tick.Tick) -> None",
      "TimeFrame": "class alphalab.market.bar.TimeFrame(count: 'int', unit: 'IntervalUnit') -> None",
      "TradeReceived": "class alphalab.market.events.TradeReceived(event_id: str, timestamp: float, tick: alphalab.market.tick.Tick) -> None",
      "UNRESOLVED_IDENTITY": "value alphalab.market.normalization.UnresolvedIdentity",
      "UnresolvedIdentity": "class alphalab.market.normalization.UnresolvedIdentity(symbols: 'SymbolMap' = <factory>) -> None",
      "UnsupportedRecordError": "class alphalab.market.exceptions.UnsupportedRecordError",
      "bars": "function alphalab.market.views.bars(state: alphalab.market.state.MarketState) -> collections.abc.Sequence[alphalab.market.bar.Bar]",
      "best_ask": "function alphalab.market.book.best_ask(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> decimal.Decimal",
      "best_bid": "function alphalab.market.book.best_bid(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> decimal.Decimal",
      "books": "function alphalab.market.views.books(state: alphalab.market.state.MarketState) -> collections.abc.Sequence[alphalab.market.snapshot.OrderBookSnapshot]",
      "is_stale": "function alphalab.market.normalization.is_stale(timestamp: 'float', now: 'float', max_age_seconds: 'float') -> 'bool'",
      "is_valid_timestamp": "function alphalab.market.timestamp.is_valid_timestamp(timestamp: float) -> bool",
      "latest_bar": "function alphalab.market.views.latest_bar(state: alphalab.market.state.MarketState, asset_id: str, timeframe: str) -> alphalab.market.bar.Bar | None",
      "latest_book": "function alphalab.market.views.latest_book(state: alphalab.market.state.MarketState, asset_id: str) -> alphalab.market.snapshot.OrderBookSnapshot | None",
      "latest_quote": "function alphalab.market.views.latest_quote(state: alphalab.market.state.MarketState, asset_id: str) -> alphalab.market.quote.Quote | None",
      "latest_tick": "function alphalab.market.views.latest_tick(state: alphalab.market.state.MarketState, asset_id: str) -> alphalab.market.tick.Tick | None",
      "mid_price": "function alphalab.market.book.mid_price(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> decimal.Decimal",
      "normalize_wire_bar": "function alphalab.market.normalization.normalize_wire_bar(bar: 'WireBar', policy: 'NormalizationPolicy') -> 'Bar'",
      "normalize_wire_bars": "function alphalab.market.provider.normalize_wire_bars(bars: 'Sequence[WireBar]', policy: 'NormalizationPolicy') -> 'tuple[Bar, ...]'",
      "normalize_wire_book": "function alphalab.market.normalization.normalize_wire_book(book: 'WireOrderBook', policy: 'NormalizationPolicy', sequence: 'int' = 1) -> 'OrderBookSnapshot'",
      "normalize_wire_quote": "function alphalab.market.normalization.normalize_wire_quote(quote: 'WireQuote', policy: 'NormalizationPolicy') -> 'Quote'",
      "normalize_wire_trade": "function alphalab.market.normalization.normalize_wire_trade(trade: 'WireTrade', policy: 'NormalizationPolicy', trade_id: 'str' = '') -> 'Tick'",
      "quotes": "function alphalab.market.views.quotes(state: alphalab.market.state.MarketState) -> collections.abc.Sequence[alphalab.market.quote.Quote]",
      "records_from_inputs": "function alphalab.market.record.records_from_inputs(stream_id: 'str', inputs: 'Sequence[MarketInput]') -> 'tuple[MarketRecord, ...]'",
      "reject_stale": "function alphalab.market.normalization.reject_stale(timestamp: 'float', now: 'float', max_age_seconds: 'float', what: 'str') -> 'None'",
      "spread": "function alphalab.market.book.spread(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> decimal.Decimal",
      "ticks": "function alphalab.market.views.ticks(state: alphalab.market.state.MarketState) -> collections.abc.Sequence[alphalab.market.tick.Tick]",
      "to_decimal": "function alphalab.market.normalization.to_decimal(value: 'float | str | Decimal') -> 'Decimal'",
      "to_unix_milliseconds": "function alphalab.market.timestamp.to_unix_milliseconds(seconds: float) -> int",
      "to_unix_seconds": "function alphalab.market.timestamp.to_unix_seconds(milliseconds: int) -> float",
      "validate_bar": "function alphalab.market.validation.validate_bar(bar: alphalab.market.bar.Bar) -> None",
      "validate_ordering": "function alphalab.market.source.validate_ordering(records: 'Sequence[MarketRecord]') -> 'None'",
      "validate_quote": "function alphalab.market.validation.validate_quote(quote: alphalab.market.quote.Quote) -> None",
      "validate_snapshot": "function alphalab.market.validation.validate_snapshot(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> None",
      "validate_tick": "function alphalab.market.validation.validate_tick(tick: alphalab.market.tick.Tick) -> None",
      "weighted_mid": "function alphalab.market.book.weighted_mid(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> decimal.Decimal"
    },
    "alphalab.marketdata": {
      "Bar": "class alphalab.data.feed.Bar(symbol: str, timestamp: float, open: float, high: float, low: float, close: float, volume: float) -> None",
      "HttpTransport": "class alphalab.marketdata.transport.HttpTransport(timeout_seconds: float = 10.0) -> None",
      "MarketDataError": "class alphalab.marketdata.exceptions.MarketDataError",
      "OrderBook": "class alphalab.data.feed.OrderBook(symbol: str, timestamp: float, bids: tuple[alphalab.data.feed.OrderBookLevel, ...] = <factory>, asks: tuple[alphalab.data.feed.OrderBookLevel, ...] = <factory>) -> None",
      "OrderBookLevel": "class alphalab.data.feed.OrderBookLevel(price: float, size: float) -> None",
      "Quote": "class alphalab.data.feed.Quote(symbol: str, timestamp: float, bid: float, ask: float, bid_size: float, ask_size: float) -> None",
      "StaticTransport": "class alphalab.marketdata.transport.StaticTransport(responses: collections.abc.Mapping[str, bytes] = <factory>, default_response: bytes = b'{}') -> None",
      "Trade": "class alphalab.data.feed.Trade(symbol: str, timestamp: float, price: float, size: float, trade_id: str = '', aggressor: alphalab.data.feed.TradeAggressor | None = None) -> None",
      "Transport": "class alphalab.marketdata.transport.Transport(*args, **kwargs)",
      "WebSocketConnection": "class alphalab.marketdata.websocket.WebSocketConnection(url: 'str', _socket: 'socket.socket', _buffer: 'bytearray' = <factory>, _closed: 'bool' = False, last_pong: 'bytes' = b'', _fragments: 'list[bytes]' = <factory>, _fragment_opcode: '_Opcode' = <_Opcode.TEXT: 1>, _released: 'bool' = False) -> None",
      "WebSocketError": "class alphalab.marketdata.websocket.WebSocketError",
      "WebSocketTransport": "class alphalab.marketdata.websocket.WebSocketTransport(headers: 'Mapping[str, str] | None' = None, timeout_seconds: 'float' = 10.0) -> 'None'",
      "connect_websocket": "function alphalab.marketdata.websocket.connect_websocket(url: 'str', *, headers: 'Mapping[str, str] | None' = None, timeout_seconds: 'float' = 10.0) -> 'WebSocketConnection'"
    },
    "alphalab.ml": {
      "ConfusionMatrix": "class alphalab.ml.evaluation.ConfusionMatrix(true_positives: int, true_negatives: int, false_positives: int, false_negatives: int) -> None",
      "Dataset": "class alphalab.ml.dataset.Dataset(feature_names: tuple[str, ...], x: tuple[tuple[float, ...], ...], y: tuple[float, ...], asset_ids: tuple[str, ...]) -> None",
      "FeatureSpec": "alias tuple[str, int]",
      "LinearRegressionModel": "class alphalab.ml.linear_regression.LinearRegressionModel(feature_names: tuple[str, ...], coefficients: tuple[float, ...], intercept: float, l2_penalty: float = 0.0) -> None",
      "LogisticRegressionModel": "class alphalab.ml.logistic_regression.LogisticRegressionModel(feature_names: tuple[str, ...], weights: tuple[float, ...], bias: float, iterations: int, learning_rate: float) -> None",
      "MLComputationError": "class alphalab.ml.exceptions.MLComputationError",
      "MLError": "class alphalab.ml.exceptions.MLError",
      "MLInputError": "class alphalab.ml.exceptions.MLInputError",
      "Matrix": "alias tuple[tuple[float, ...], ...]",
      "TrainTestSplit": "alias tuple[tuple[int, ...], tuple[int, ...]]",
      "accuracy": "function alphalab.ml.evaluation.accuracy(y_true: tuple[int, ...], y_pred: tuple[int, ...]) -> float",
      "build_dataset_from_feature_store": "function alphalab.ml.dataset.build_dataset_from_feature_store(state: alphalab.feature_store.state.FeatureStoreState, feature_specs: tuple[tuple[str, int], ...], target_spec: tuple[str, int], asset_ids: tuple[str, ...]) -> alphalab.ml.dataset.Dataset",
      "confusion_matrix": "function alphalab.ml.evaluation.confusion_matrix(y_true: tuple[int, ...], y_pred: tuple[int, ...]) -> alphalab.ml.evaluation.ConfusionMatrix",
      "f1_score": "function alphalab.ml.evaluation.f1_score(y_true: tuple[int, ...], y_pred: tuple[int, ...]) -> float",
      "identity": "function alphalab.ml.linalg.identity(n: int) -> tuple[tuple[float, ...], ...]",
      "k_fold_split": "function alphalab.ml.cross_validation.k_fold_split(n_samples: int, k: int) -> tuple[tuple[tuple[int, ...], tuple[int, ...]], ...]",
      "matmul": "function alphalab.ml.linalg.matmul(a: tuple[tuple[float, ...], ...], b: tuple[tuple[float, ...], ...]) -> tuple[tuple[float, ...], ...]",
      "matrix_inverse": "function alphalab.ml.linalg.matrix_inverse(matrix: tuple[tuple[float, ...], ...]) -> tuple[tuple[float, ...], ...]",
      "mean_absolute_error": "function alphalab.ml.evaluation.mean_absolute_error(y_true: tuple[float, ...], y_pred: tuple[float, ...]) -> float",
      "mean_squared_error": "function alphalab.ml.evaluation.mean_squared_error(y_true: tuple[float, ...], y_pred: tuple[float, ...]) -> float",
      "precision": "function alphalab.ml.evaluation.precision(y_true: tuple[int, ...], y_pred: tuple[int, ...]) -> float",
      "predict_linear": "function alphalab.ml.linear_regression.predict_linear(model: alphalab.ml.linear_regression.LinearRegressionModel, x: tuple[tuple[float, ...], ...]) -> tuple[float, ...]",
      "predict_logistic": "function alphalab.ml.logistic_regression.predict_logistic(model: alphalab.ml.logistic_regression.LogisticRegressionModel, x: tuple[tuple[float, ...], ...], threshold: float = 0.5) -> tuple[int, ...]",
      "predict_proba_logistic": "function alphalab.ml.logistic_regression.predict_proba_logistic(model: alphalab.ml.logistic_regression.LogisticRegressionModel, x: tuple[tuple[float, ...], ...]) -> tuple[float, ...]",
      "r_squared": "function alphalab.ml.evaluation.r_squared(y_true: tuple[float, ...], y_pred: tuple[float, ...]) -> float",
      "recall": "function alphalab.ml.evaluation.recall(y_true: tuple[int, ...], y_pred: tuple[int, ...]) -> float",
      "root_mean_squared_error": "function alphalab.ml.evaluation.root_mean_squared_error(y_true: tuple[float, ...], y_pred: tuple[float, ...]) -> float",
      "train_linear_regression": "function alphalab.ml.linear_regression.train_linear_regression(feature_names: tuple[str, ...], x: tuple[tuple[float, ...], ...], y: tuple[float, ...], l2_penalty: float = 0.0, *, maximum_condition: float = 1000000.0) -> alphalab.ml.linear_regression.LinearRegressionModel",
      "train_logistic_regression": "function alphalab.ml.logistic_regression.train_logistic_regression(feature_names: tuple[str, ...], x: tuple[tuple[float, ...], ...], y: tuple[int, ...], learning_rate: float = 0.1, iterations: int = 1000) -> alphalab.ml.logistic_regression.LogisticRegressionModel",
      "transpose": "function alphalab.ml.linalg.transpose(matrix: tuple[tuple[float, ...], ...]) -> tuple[tuple[float, ...], ...]",
      "walk_forward_split": "function alphalab.ml.cross_validation.walk_forward_split(n_samples: int, n_splits: int, min_train_size: int, expanding: bool = True) -> tuple[tuple[tuple[int, ...], tuple[int, ...]], ...]"
    },
    "alphalab.model_registry": {
      "ARTIFACT_URI_SCHEME": "value builtins.str",
      "ArtifactRef": "class alphalab.model_registry.registry.ArtifactRef(uri: str, media_type: str = '', checksum: str = '', size_bytes: int | None = None) -> None",
      "ArtifactStore": "class alphalab.model_registry.artifact_store.ArtifactStore(*args, **kwargs)",
      "DEFAULT_MEDIA_TYPE": "value builtins.str",
      "DeploymentMetadata": "class alphalab.model_registry.registry.DeploymentMetadata(environment: str, deployed_at: float, deployed_by: str, notes: str = '') -> None",
      "EvidenceIndex": "class alphalab.model_registry.evidence.EvidenceIndex(*args, **kwargs)",
      "EvidenceItem": "class alphalab.model_registry.evidence.EvidenceItem(ref: 'EvidenceRef', value: 'Any') -> None",
      "EvidenceRef": "class alphalab.model_registry.evidence.EvidenceRef(kind: 'str', identity: 'str', digest: 'str') -> None",
      "EvidenceStore": "class alphalab.model_registry.evidence.EvidenceStore(artifacts: 'ArtifactStore', index: 'EvidenceIndex') -> 'None'",
      "FileArtifactStore": "class alphalab.model_registry.artifact_store.FileArtifactStore(root: 'Path | str') -> 'None'",
      "FileEvidenceIndex": "class alphalab.model_registry.evidence.FileEvidenceIndex(root: 'Path | str') -> 'None'",
      "LEGAL_TRANSITIONS": "value builtins.dict",
      "MemoryArtifactStore": "class alphalab.model_registry.artifact_store.MemoryArtifactStore() -> 'None'",
      "MemoryEvidenceIndex": "class alphalab.model_registry.evidence.MemoryEvidenceIndex(entries: 'dict[tuple[str, str], str]' = <factory>) -> None",
      "ModelRegistry": "class alphalab.model_registry.registry.ModelRegistry(versions: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentMap[int, alphalab.model_registry.registry.ModelVersion]] = <factory>, promotions: alphalab.common.append_log.AppendOnlyLog[alphalab.model_registry.registry.PromotionRecord] = <factory>, production: alphalab.common.persistent_map.PersistentMap[str, int] = <factory>, production_line: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.append_log.AppendOnlyLog[int]] = <factory>) -> None",
      "ModelRegistryError": "class alphalab.model_registry.exceptions.ModelRegistryError",
      "ModelRegistryInputError": "class alphalab.model_registry.exceptions.ModelRegistryInputError",
      "ModelStage": "enum alphalab.model_registry.registry.ModelStage[NONE, STAGING, PRODUCTION, ARCHIVED]",
      "ModelVersion": "class alphalab.model_registry.registry.ModelVersion(name: str, version: int, model: object, stage: alphalab.model_registry.registry.ModelStage, metrics: collections.abc.Mapping[str, float] = <factory>, parameters: collections.abc.Mapping[str, ParamValue] = <factory>, tags: collections.abc.Mapping[str, str] = <factory>, run_id: str | None = None, created_at: float = 0.0, deployment: alphalab.model_registry.registry.DeploymentMetadata | None = None, artifact: alphalab.model_registry.registry.ArtifactRef | None = None) -> None",
      "ParamValue": "alias ParamValue",
      "PromotionRecord": "class alphalab.model_registry.registry.PromotionRecord(name: str, version: int, from_stage: alphalab.model_registry.registry.ModelStage, to_stage: alphalab.model_registry.registry.ModelStage, timestamp: float) -> None",
      "SelfIdentified": "class alphalab.model_registry.evidence.SelfIdentified(*args, **kwargs)",
      "artifact_uri": "function alphalab.model_registry.artifact_store.artifact_uri(digest: 'str') -> 'str'",
      "compute_digest": "function alphalab.model_registry.artifact_store.compute_digest(payload: 'bytes') -> 'str'",
      "deployed_versions": "function alphalab.model_registry.deployment.deployed_versions(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> tuple[alphalab.model_registry.registry.ModelVersion, ...]",
      "deployment_metadata": "function alphalab.model_registry.deployment.deployment_metadata(registry: alphalab.model_registry.registry.ModelRegistry, name: str, version: int) -> alphalab.model_registry.registry.DeploymentMetadata | None",
      "digest_of": "function alphalab.model_registry.artifact_store.digest_of(ref: 'ArtifactRef') -> 'str'",
      "file_evidence_store": "function alphalab.model_registry.evidence.file_evidence_store(root: 'Path | str') -> 'EvidenceStore'",
      "get_model": "function alphalab.model_registry.registry.get_model(registry: alphalab.model_registry.registry.ModelRegistry, name: str, version: int, expected_type: type[ModelT]) -> ModelT",
      "get_version": "function alphalab.model_registry.registry.get_version(registry: alphalab.model_registry.registry.ModelRegistry, name: str, version: int) -> alphalab.model_registry.registry.ModelVersion",
      "illegal_stage_move": "function alphalab.model_registry.stages.illegal_stage_move(current: alphalab.model_registry.registry.ModelStage, target: alphalab.model_registry.registry.ModelStage) -> str | None",
      "latest_version": "function alphalab.model_registry.registry.latest_version(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> alphalab.model_registry.registry.ModelVersion",
      "list_versions": "function alphalab.model_registry.registry.list_versions(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> tuple[alphalab.model_registry.registry.ModelVersion, ...]",
      "memory_evidence_store": "function alphalab.model_registry.evidence.memory_evidence_store() -> 'EvidenceStore'",
      "model_names": "function alphalab.model_registry.registry.model_names(registry: alphalab.model_registry.registry.ModelRegistry) -> tuple[str, ...]",
      "previous_production_version": "function alphalab.model_registry.stages.previous_production_version(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> int | None",
      "production_version": "function alphalab.model_registry.promotion.production_version(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> alphalab.model_registry.registry.ModelVersion | None",
      "promote": "function alphalab.model_registry.promotion.promote(registry: alphalab.model_registry.registry.ModelRegistry, name: str, version: int, stage: alphalab.model_registry.registry.ModelStage, timestamp: float) -> alphalab.model_registry.registry.ModelRegistry",
      "promotion_history": "function alphalab.model_registry.rollback.promotion_history(registry: alphalab.model_registry.registry.ModelRegistry, name: str | None = None) -> tuple[alphalab.model_registry.registry.PromotionRecord, ...]",
      "register_model": "function alphalab.model_registry.registry.register_model(registry: alphalab.model_registry.registry.ModelRegistry, name: str, model: object, timestamp: float, metrics: collections.abc.Mapping[str, float] | None = None, parameters: collections.abc.Mapping[str, ParamValue] | None = None, tags: collections.abc.Mapping[str, str] | None = None, run_id: str | None = None, artifact: alphalab.model_registry.registry.ArtifactRef | None = None) -> tuple[alphalab.model_registry.registry.ModelRegistry, alphalab.model_registry.registry.ModelVersion]",
      "rollback": "function alphalab.model_registry.rollback.rollback(registry: alphalab.model_registry.registry.ModelRegistry, name: str, timestamp: float) -> alphalab.model_registry.registry.ModelRegistry",
      "set_deployment_metadata": "function alphalab.model_registry.deployment.set_deployment_metadata(registry: alphalab.model_registry.registry.ModelRegistry, name: str, version: int, metadata: alphalab.model_registry.registry.DeploymentMetadata) -> alphalab.model_registry.registry.ModelRegistry",
      "staging_version": "function alphalab.model_registry.promotion.staging_version(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> alphalab.model_registry.registry.ModelVersion | None",
      "validate_transition": "function alphalab.model_registry.stages.validate_transition(registry: alphalab.model_registry.registry.ModelRegistry, name: str, version: int, current: alphalab.model_registry.registry.ModelStage, target: alphalab.model_registry.registry.ModelStage) -> None",
      "verify_artifact": "function alphalab.model_registry.artifact_store.verify_artifact(ref: 'ArtifactRef', payload: 'bytes') -> 'bytes'",
      "versions_in_stage": "function alphalab.model_registry.promotion.versions_in_stage(registry: alphalab.model_registry.registry.ModelRegistry, name: str, stage: alphalab.model_registry.registry.ModelStage) -> tuple[alphalab.model_registry.registry.ModelVersion, ...]"
    },
    "alphalab.oms": {
      "DuplicateOrderError": "class alphalab.oms.exceptions.DuplicateOrderError",
      "InvalidTransitionError": "class alphalab.oms.exceptions.InvalidTransitionError",
      "OMSEngine": "class alphalab.oms.engine.OMSEngine()",
      "OMSError": "class alphalab.oms.exceptions.OMSError",
      "OMSEvent": "class alphalab.oms.events.OMSEvent(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId) -> None",
      "OMSEventRecord": "class alphalab.oms.snapshot.OMSEventRecord(event_type: 'str', event: 'OMSEvent') -> None",
      "OMSSnapshot": "class alphalab.oms.snapshot.OMSSnapshot(orders: 'tuple[Order, ...]', active_orders: 'tuple[OrderId, ...]', completed_orders: 'tuple[OrderId, ...]', history: 'tuple[OMSEventRecord, ...]', events: 'tuple[OMSEventRecord, ...]', schema_version: 'int' = 2) -> None",
      "OMSState": "class alphalab.oms.state.OMSState(orders: alphalab.oms.book.OrderBook = <factory>, active_orders: alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId] = <factory>, completed_orders: alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId] = <factory>, history: alphalab.common.append_log.AppendOnlyLog[alphalab.oms.events.OMSEvent] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.oms.events.OMSEvent] = <factory>, working_by_asset: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId]] = <factory>) -> None",
      "Order": "class alphalab.oms.order.Order(order_id: 'OrderId', strategy_id: 'str', asset_id: 'str', side: 'Side', order_type: 'OrderType', status: 'OrderStatus', quantity: 'Decimal', filled_quantity: 'Decimal', remaining_quantity: 'Decimal', limit_price: 'Decimal | None', stop_price: 'Decimal | None', average_fill_price: 'Decimal', created_at: 'float', updated_at: 'float', metadata: 'Mapping[str, str]' = <factory>, time_in_force: 'TimeInForce' = <TimeInForce.DAY: 'day'>, expire_at: 'float | None' = None, triggered_at: 'float | None' = None) -> None",
      "OrderAccepted": "class alphalab.oms.events.OrderAccepted(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId) -> None",
      "OrderBook": "class alphalab.oms.book.OrderBook(_orders: alphalab.common.persistent_map.PersistentMap[alphalab.oms.ids.OrderId, alphalab.oms.order.Order] = <factory>, _by_asset: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId]] = <factory>, _by_strategy: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId]] = <factory>) -> None",
      "OrderCancelled": "class alphalab.oms.events.OrderCancelled(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId) -> None",
      "OrderExpired": "class alphalab.oms.events.OrderExpired(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId) -> None",
      "OrderFilled": "class alphalab.oms.events.OrderFilled(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, fill_quantity: decimal.Decimal, fill_price: decimal.Decimal) -> None",
      "OrderId": "class alphalab.oms.ids.OrderId(value: 'uuid.UUID') -> None",
      "OrderPartiallyFilled": "class alphalab.oms.events.OrderPartiallyFilled(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, fill_quantity: decimal.Decimal, fill_price: decimal.Decimal) -> None",
      "OrderRejected": "class alphalab.oms.events.OrderRejected(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, reason: str) -> None",
      "OrderReplaced": "class alphalab.oms.events.OrderReplaced(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, new_quantity: decimal.Decimal, new_limit_price: decimal.Decimal | None) -> None",
      "OrderStatus": "enum alphalab.core.enums.OrderStatus[NEW, PENDING, ACCEPTED, PARTIALLY_FILLED, FILLED, CANCEL_PENDING, CANCELLED, REJECTED, EXPIRED]",
      "OrderSubmitted": "class alphalab.oms.events.OrderSubmitted(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, order: alphalab.oms.order.Order) -> None",
      "OrderType": "enum alphalab.common.order_terms.OrderType[MARKET, LIMIT, STOP, STOP_LIMIT]",
      "OrderValidationError": "class alphalab.oms.exceptions.OrderValidationError",
      "Side": "enum alphalab.core.enums.Side[BUY, SELL]",
      "SnapshotDecodeError": "class alphalab.oms.snapshot.SnapshotDecodeError",
      "UnknownOrderError": "class alphalab.oms.exceptions.UnknownOrderError",
      "active_orders": "function alphalab.oms.views.active_orders(state: alphalab.oms.state.OMSState) -> collections.abc.Sequence[alphalab.oms.order.Order]",
      "capture": "function alphalab.oms.snapshot.capture(state: 'OMSState') -> 'OMSSnapshot'",
      "completed_orders": "function alphalab.oms.views.completed_orders(state: alphalab.oms.state.OMSState) -> collections.abc.Sequence[alphalab.oms.order.Order]",
      "filled_volume": "function alphalab.oms.views.filled_volume(state: alphalab.oms.state.OMSState, asset_id: str) -> decimal.Decimal",
      "from_primitives": "function alphalab.oms.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'OMSSnapshot'",
      "order": "function alphalab.oms.views.order(state: alphalab.oms.state.OMSState, order_id: alphalab.oms.ids.OrderId) -> alphalab.oms.order.Order",
      "orders": "function alphalab.oms.views.orders(state: alphalab.oms.state.OMSState) -> collections.abc.Sequence[alphalab.oms.order.Order]",
      "orders_for_asset": "function alphalab.oms.views.orders_for_asset(state: alphalab.oms.state.OMSState, asset_id: str) -> collections.abc.Sequence[alphalab.oms.order.Order]",
      "orders_for_strategy": "function alphalab.oms.views.orders_for_strategy(state: alphalab.oms.state.OMSState, strategy_id: str) -> collections.abc.Sequence[alphalab.oms.order.Order]",
      "restore": "function alphalab.oms.snapshot.restore(snapshot: 'OMSSnapshot') -> 'OMSState'",
      "validate_order": "function alphalab.oms.validation.validate_order(order: alphalab.oms.order.Order, current_timestamp: float) -> None"
    },
    "alphalab.oms.snapshot": {
      "LEGACY_UNVERSIONED_V0_KEYS": "value builtins.frozenset",
      "OMSEventRecord": "class alphalab.oms.snapshot.OMSEventRecord(event_type: 'str', event: 'OMSEvent') -> None",
      "OMSSnapshot": "class alphalab.oms.snapshot.OMSSnapshot(orders: 'tuple[Order, ...]', active_orders: 'tuple[OrderId, ...]', completed_orders: 'tuple[OrderId, ...]', history: 'tuple[OMSEventRecord, ...]', events: 'tuple[OMSEventRecord, ...]', schema_version: 'int' = 2) -> None",
      "OMS_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "OMS_SNAPSHOT_SCHEMA": "value builtins.int",
      "SnapshotDecodeError": "class alphalab.oms.snapshot.SnapshotDecodeError",
      "capture": "function alphalab.oms.snapshot.capture(state: 'OMSState') -> 'OMSSnapshot'",
      "from_primitives": "function alphalab.oms.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'OMSSnapshot'",
      "order_v1_to_v2": "function alphalab.oms.snapshot.order_v1_to_v2(order: 'Any') -> 'Any'",
      "restore": "function alphalab.oms.snapshot.restore(snapshot: 'OMSSnapshot') -> 'OMSState'"
    },
    "alphalab.options": {
      "BLACK_SCHOLES_MERTON": "value alphalab.options.model.ModelAssumptions",
      "BinomialLattice": "class alphalab.options.binomial.BinomialLattice(steps: 'int', dividends: 'tuple[CashDividend, ...]') -> None",
      "Carry": "class alphalab.options.carry.Carry(kind: 'CarryKind', yield_rate: 'float') -> None",
      "CarryKind": "enum alphalab.options.carry.CarryKind[DIVIDEND_YIELD, FOREIGN_RATE, FUTURES]",
      "CashDividend": "class alphalab.options.binomial.CashDividend(ex_timestamp: 'float', amount: 'Decimal') -> None",
      "ExerciseStyle": "enum alphalab.options.enums.ExerciseStyle[AMERICAN, EUROPEAN]",
      "ExpirationOutcome": "enum alphalab.options.expiration.ExpirationOutcome[EXPIRED_WORTHLESS, EXERCISED, ASSIGNED, ABANDONED]",
      "ExpirationPolicy": "class alphalab.options.expiration.ExpirationPolicy(settlement: 'SettlementStyle', exercise_in_the_money: 'bool') -> None",
      "ExpirationResult": "class alphalab.options.expiration.ExpirationResult(contract_symbol: 'str', outcome: 'ExpirationOutcome', moneyness: 'Moneyness', contracts: 'Decimal', intrinsic_per_unit: 'Decimal', cash_flow: 'Decimal', underlying_units: 'Decimal') -> None",
      "ExpiryInterpolation": "enum alphalab.options.volatility_surface.ExpiryInterpolation[TOTAL_VARIANCE_LINEAR]",
      "FUTURES_CARRY": "value alphalab.options.carry.Carry",
      "Greeks": "class alphalab.options.greeks.Greeks(delta: float, gamma: float, theta: float, vega: float, rho: float) -> None",
      "ImpliedVolatility": "class alphalab.options.implied.ImpliedVolatility(value: 'float', market_price: 'float', repriced: 'float', vega: 'float', iterations: 'int', assumptions: 'ModelAssumptions', carry: 'Carry', lattice: 'BinomialLattice | None' = None) -> None",
      "ImpliedVolatilityError": "class alphalab.options.implied.ImpliedVolatilityError",
      "MAX_STEPS": "value builtins.int",
      "ModelAssumptions": "class alphalab.options.model.ModelAssumptions(model: 'PricingModel', year_basis_days: 'float', prices_early_exercise: 'bool', models_dividends: 'bool', models_volatility_smile: 'bool', note: 'str', models_discrete_dividends: 'bool' = False, steps: 'int | None' = None) -> None",
      "Moneyness": "enum alphalab.options.expiration.Moneyness[IN_THE_MONEY, AT_THE_MONEY, OUT_OF_THE_MONEY]",
      "OptionChain": "class alphalab.options.chain.OptionChain(underlying_asset_id: str, timestamp: float, contracts: tuple[alphalab.options.contract.OptionContract, ...]) -> None",
      "OptionContract": "class alphalab.options.contract.OptionContract(underlying_asset_id: str, strike: decimal.Decimal, expiry: float, option_type: alphalab.options.enums.OptionType, style: alphalab.options.enums.ExerciseStyle, multiplier: int) -> None",
      "OptionInputError": "class alphalab.options.exceptions.OptionInputError",
      "OptionLeg": "class alphalab.options.strategy.OptionLeg(contract: alphalab.options.contract.OptionContract, side: alphalab.core.enums.Side, quantity: int) -> None",
      "OptionPricingError": "class alphalab.options.exceptions.OptionPricingError",
      "OptionStrategy": "class alphalab.options.strategy.OptionStrategy(legs: tuple[alphalab.options.strategy.OptionLeg, ...]) -> None",
      "OptionType": "enum alphalab.options.enums.OptionType[CALL, PUT]",
      "OptionsError": "class alphalab.options.exceptions.OptionsError",
      "PricingModel": "enum alphalab.options.model.PricingModel[BLACK_SCHOLES, BINOMIAL_CRR]",
      "SettlementStyle": "enum alphalab.options.expiration.SettlementStyle[PHYSICAL, CASH]",
      "SurfaceRefusal": "class alphalab.options.volatility_surface.SurfaceRefusal(contract_symbol: str, strike: float, expiry: float, reason: str) -> None",
      "VolPoint": "class alphalab.options.volatility_surface.VolPoint(strike: float, expiry: float, implied_vol: float) -> None",
      "VolSlice": "class alphalab.options.volatility_surface.VolSlice(underlying_asset_id: str, expiry: float, points: tuple[alphalab.options.volatility_surface.VolPoint, ...]) -> None",
      "VolatilitySurface": "class alphalab.options.volatility_surface.VolatilitySurface(underlying_asset_id: str, timestamp: float, points: tuple[alphalab.options.volatility_surface.VolPoint, ...]) -> None",
      "binomial_greeks": "function alphalab.options.binomial.binomial_greeks(contract: 'OptionContract', spot: 'Decimal', volatility: 'float', risk_free_rate: 'float', valuation_timestamp: 'float', *, carry: 'Carry', lattice: 'BinomialLattice') -> 'Greeks'",
      "binomial_price": "function alphalab.options.binomial.binomial_price(contract: 'OptionContract', spot: 'Decimal', volatility: 'float', risk_free_rate: 'float', valuation_timestamp: 'float', *, carry: 'Carry', lattice: 'BinomialLattice') -> 'Decimal'",
      "binomial_value": "function alphalab.options.binomial.binomial_value(contract: 'OptionContract', spot: 'float', volatility: 'float', risk_free_rate: 'float', valuation_timestamp: 'float', *, carry: 'Carry', lattice: 'BinomialLattice') -> 'float'",
      "black_scholes_greeks": "function alphalab.options.pricing.black_scholes_greeks(contract: alphalab.options.contract.OptionContract, spot: decimal.Decimal, volatility: float, risk_free_rate: float, valuation_timestamp: float, *, carry: alphalab.options.carry.Carry) -> alphalab.options.greeks.Greeks",
      "black_scholes_price": "function alphalab.options.pricing.black_scholes_price(contract: alphalab.options.contract.OptionContract, spot: decimal.Decimal, volatility: float, risk_free_rate: float, valuation_timestamp: float, *, carry: alphalab.options.carry.Carry) -> decimal.Decimal",
      "black_scholes_value": "function alphalab.options.pricing.black_scholes_value(contract: alphalab.options.contract.OptionContract, spot: float, volatility: float, risk_free_rate: float, years: float, *, carry: alphalab.options.carry.Carry) -> float",
      "by_expiry": "function alphalab.options.chain.by_expiry(chain: alphalab.options.chain.OptionChain, expiry: float) -> tuple[alphalab.options.contract.OptionContract, ...]",
      "calls": "function alphalab.options.chain.calls(chain: alphalab.options.chain.OptionChain) -> tuple[alphalab.options.contract.OptionContract, ...]",
      "compute_payoff_at_expiry": "function alphalab.options.strategy.compute_payoff_at_expiry(strategy: alphalab.options.strategy.OptionStrategy, spot_price: decimal.Decimal) -> decimal.Decimal",
      "compute_pnl": "function alphalab.options.strategy.compute_pnl(strategy: alphalab.options.strategy.OptionStrategy, entry_prices: collections.abc.Mapping[str, decimal.Decimal], spot_price: decimal.Decimal) -> decimal.Decimal",
      "dividend_yield": "function alphalab.options.carry.dividend_yield(q: 'float') -> 'Carry'",
      "expiries": "function alphalab.options.chain.expiries(chain: alphalab.options.chain.OptionChain) -> tuple[float, ...]",
      "foreign_rate": "function alphalab.options.carry.foreign_rate(rate: 'float') -> 'Carry'",
      "implied_vol_across_expiries": "function alphalab.options.volatility_surface.implied_vol_across_expiries(surface: alphalab.options.volatility_surface.VolatilitySurface, strike: float, expiry: float, *, method: alphalab.options.volatility_surface.ExpiryInterpolation) -> float",
      "implied_vol_at": "function alphalab.options.volatility_surface.implied_vol_at(surface: alphalab.options.volatility_surface.VolatilitySurface, strike: float, expiry: float) -> float | None",
      "implied_volatility": "function alphalab.options.implied.implied_volatility(contract: 'OptionContract', market_price: 'Decimal', spot: 'Decimal', risk_free_rate: 'float', valuation_timestamp: 'float', *, carry: 'Carry', lattice: 'BinomialLattice | None' = None) -> 'ImpliedVolatility'",
      "intrinsic_value": "function alphalab.options.expiration.intrinsic_value(contract: 'OptionContract', settlement_price: 'Decimal') -> 'Decimal'",
      "moneyness": "function alphalab.options.expiration.moneyness(contract: 'OptionContract', settlement_price: 'Decimal') -> 'Moneyness'",
      "net_greeks": "function alphalab.options.strategy.net_greeks(strategy: alphalab.options.strategy.OptionStrategy, greeks_by_symbol: collections.abc.Mapping[str, alphalab.options.greeks.Greeks]) -> alphalab.options.greeks.Greeks",
      "net_premium": "function alphalab.options.strategy.net_premium(strategy: alphalab.options.strategy.OptionStrategy, entry_prices: collections.abc.Mapping[str, decimal.Decimal]) -> decimal.Decimal",
      "occ_symbol": "function alphalab.options.contract.occ_symbol(contract: alphalab.options.contract.OptionContract) -> str",
      "open_option_position": "function alphalab.options.contract.open_option_position(contract: alphalab.options.contract.OptionContract, quantity: decimal.Decimal, price: decimal.Decimal, timestamp: float, currency: str, *, minor_units: int | None = None) -> alphalab.portfolio.position.Position",
      "puts": "function alphalab.options.chain.puts(chain: alphalab.options.chain.OptionChain) -> tuple[alphalab.options.contract.OptionContract, ...]",
      "resolve_expiration": "function alphalab.options.expiration.resolve_expiration(contract: 'OptionContract', contracts: 'Decimal', settlement_price: 'Decimal', policy: 'ExpirationPolicy') -> 'ExpirationResult'",
      "resolve_strategy_expiration": "function alphalab.options.expiration.resolve_strategy_expiration(strategy: 'OptionStrategy', settlement_price: 'Decimal', policy: 'ExpirationPolicy') -> 'tuple[ExpirationResult, ...]'",
      "signed_quantity": "function alphalab.options.strategy.signed_quantity(leg: alphalab.options.strategy.OptionLeg) -> decimal.Decimal",
      "strikes_for_expiry": "function alphalab.options.chain.strikes_for_expiry(chain: alphalab.options.chain.OptionChain, expiry: float) -> tuple[float, ...]",
      "surface_expiries": "function alphalab.options.volatility_surface.surface_expiries(surface: alphalab.options.volatility_surface.VolatilitySurface) -> tuple[float, ...]",
      "surface_from_chain": "function alphalab.options.volatility_surface.surface_from_chain(chain: alphalab.options.chain.OptionChain, market_prices: collections.abc.Mapping[str, decimal.Decimal], spot: decimal.Decimal, risk_free_rate: float, valuation_timestamp: float, *, carry: alphalab.options.carry.Carry, lattice: alphalab.options.binomial.BinomialLattice | None = None) -> tuple[alphalab.options.volatility_surface.VolatilitySurface, tuple[alphalab.options.volatility_surface.SurfaceRefusal, ...]]",
      "surface_slice": "function alphalab.options.volatility_surface.surface_slice(surface: alphalab.options.volatility_surface.VolatilitySurface, expiry: float) -> alphalab.options.volatility_surface.VolSlice",
      "term_structure": "function alphalab.options.volatility_surface.term_structure(surface: alphalab.options.volatility_surface.VolatilitySurface, strike: float) -> tuple[tuple[float, float], ...]",
      "time_to_expiry_years": "function alphalab.options.pricing.time_to_expiry_years(contract: alphalab.options.contract.OptionContract, valuation_timestamp: float) -> float"
    },
    "alphalab.persistence": {
      "FileRunStateStore": "class alphalab.persistence.run_store.FileRunStateStore(root: 'Path | str') -> 'None'",
      "MemoryRunStateStore": "class alphalab.persistence.run_store.MemoryRunStateStore() -> 'None'",
      "PersistenceError": "class alphalab.persistence.exceptions.PersistenceError",
      "PersistenceValidationError": "class alphalab.persistence.exceptions.PersistenceValidationError",
      "RUN_STATE_ENVELOPE_SCHEMA": "value builtins.int",
      "RunStateRef": "class alphalab.persistence.run_state.RunStateRef(run_id: 'str', sequence: 'int') -> None",
      "RunStateStore": "class alphalab.persistence.run_store.RunStateStore(*args, **kwargs)",
      "SerializationError": "class alphalab.persistence.exceptions.SerializationError",
      "StateDecodeError": "class alphalab.persistence.exceptions.StateDecodeError",
      "StorageError": "class alphalab.persistence.exceptions.StorageError",
      "as_decimal": "function alphalab.persistence.decode.as_decimal(value: 'Any', field: 'str') -> 'Decimal'",
      "as_float": "function alphalab.persistence.decode.as_float(value: 'Any', field: 'str') -> 'float'",
      "as_int": "function alphalab.persistence.decode.as_int(value: 'Any', field: 'str') -> 'int'",
      "as_mapping": "function alphalab.persistence.decode.as_mapping(value: 'Any', field: 'str') -> 'Mapping[str, Any]'",
      "as_named_enum": "function alphalab.persistence.decode.as_named_enum(enum_cls: 'type[EnumT]', value: 'Any', field: 'str') -> 'EnumT'",
      "as_sequence": "function alphalab.persistence.decode.as_sequence(value: 'Any', field: 'str') -> 'Sequence[Any]'",
      "as_str": "function alphalab.persistence.decode.as_str(value: 'Any', field: 'str') -> 'str'",
      "as_value_enum": "function alphalab.persistence.decode.as_value_enum(enum_cls: 'type[EnumT]', value: 'Any', field: 'str') -> 'EnumT'",
      "deserialize": "function alphalab.persistence.serializer.deserialize(payload: str) -> Any",
      "ensure_directory": "function alphalab.persistence.durable.ensure_directory(directory: 'str | os.PathLike[str]') -> 'None'",
      "fsync_directory": "function alphalab.persistence.durable.fsync_directory(directory: 'str | os.PathLike[str]') -> 'None'",
      "require": "function alphalab.persistence.decode.require(payload: 'Mapping[str, Any]', key: 'str') -> 'Any'",
      "require_schema_version": "function alphalab.persistence.decode.require_schema_version(payload: 'Mapping[str, Any]', supported: 'int', subsystem: 'str') -> 'int'",
      "serialize": "function alphalab.persistence.serializer.serialize(obj: Any) -> str"
    },
    "alphalab.portfolio": {
      "Account": "class alphalab.portfolio.account.Account(account_id: str, base_currency: str, name: str, created_at: float, status: str = 'ACTIVE', metadata: collections.abc.Mapping[str, Any] = <factory>, currency_units: alphalab.common.currency_units.CurrencyUnits = CurrencyUnits({})) -> None",
      "BOOK_VALUATION_SCHEME": "value builtins.str",
      "BookValuation": "class alphalab.portfolio.multi_strategy.BookValuation(portfolio_id: 'str', book_id: 'str', reporting_currency: 'str', as_of: 'float', lines: 'tuple[HoldingValuation, ...]', strategies: 'tuple[StrategyValuation, ...]', instruments: 'tuple[InstrumentValuation, ...]', exposure_by_currency: 'CurrencyAmounts', reporting_exposure_by_currency: 'Mapping[str, Decimal]', long_exposure: 'Decimal', short_exposure: 'Decimal', net_exposure: 'Decimal', gross_exposure: 'Decimal', cash: 'Decimal', unassigned_cash: 'Decimal', nav: 'Decimal', conversions: 'tuple[FxConversion, ...]') -> None",
      "CashDeposited": "class alphalab.portfolio.events.CashDeposited(timestamp: float, account_id: str, amount: decimal.Decimal, currency: str) -> None",
      "CashFlow": "class alphalab.portfolio.corporate_actions.CashFlow(kind: 'CashFlowKind', amount: 'Decimal', currency: 'str', asset_id: 'str' = '', reference: 'str' = '') -> None",
      "CashFlowBooked": "class alphalab.portfolio.events.CashFlowBooked(timestamp: float, account_id: str, kind: str, asset_id: str, amount: decimal.Decimal, currency: str, reference: str) -> None",
      "CashFlowKind": "enum alphalab.portfolio.corporate_actions.CashFlowKind[DIVIDEND, INTEREST, FEE, FUNDING]",
      "CashLedger": "class alphalab.portfolio.cash.CashLedger(balances: collections.abc.Mapping[str, decimal.Decimal] = <factory>, reserved: collections.abc.Mapping[str, decimal.Decimal] = <factory>) -> None",
      "CashWithdrawn": "class alphalab.portfolio.events.CashWithdrawn(timestamp: float, account_id: str, amount: decimal.Decimal, currency: str) -> None",
      "ContractExposure": "class alphalab.portfolio.contracts.ContractExposure(by_asset: 'Mapping[str, ContractNotional]', net: 'CurrencyAmounts', gross: 'CurrencyAmounts', underlying_units: 'Mapping[str, Decimal]') -> None",
      "ContractHolding": "class alphalab.portfolio.contracts.ContractHolding(position: 'Position', convention: 'MarketConvention') -> None",
      "CurrencyAttribution": "class alphalab.portfolio.fx_research.CurrencyAttribution(currency: 'str', opening_local: 'Decimal', closing_local: 'Decimal', opening_reporting: 'Decimal', closing_reporting: 'Decimal', opening_rate: 'FxRate', closing_rate: 'FxRate', local_return: 'Decimal', currency_return: 'Decimal', total: 'Decimal') -> None",
      "CurrencyAttributionReport": "class alphalab.portfolio.fx_research.CurrencyAttributionReport(reporting_currency: 'str', opening_timestamp: 'float', closing_timestamp: 'float', by_currency: 'tuple[CurrencyAttribution, ...]', local_return: 'Decimal', currency_return: 'Decimal', total: 'Decimal', rounding: 'Decimal') -> None",
      "ExposureEngine": "class alphalab.portfolio.exposure.ExposureEngine()",
      "ForwardTerms": "class alphalab.portfolio.fx_research.ForwardTerms(value_date: 'date', spot_date: 'date', base_rate: 'float', quote_rate: 'float', basis: 'DayCount') -> None",
      "FutureDatedRateError": "class alphalab.portfolio.fx.FutureDatedRateError",
      "FxConversion": "class alphalab.portfolio.fx.FxConversion(amount: 'Decimal', converted: 'Decimal', rate: 'FxRate') -> None",
      "FxRate": "class alphalab.portfolio.fx.FxRate(base: 'str', quote: 'str', rate: 'Decimal', as_of: 'float', source: 'str', derived: 'bool' = False) -> None",
      "FxRates": "class alphalab.portfolio.fx.FxRates(rates: 'Mapping[tuple[str, str], FxRate]' = <factory>, max_age_seconds: 'float | None' = None, currency_units: 'CurrencyUnits' = CurrencyUnits({})) -> None",
      "HoldingValuation": "class alphalab.portfolio.multi_strategy.HoldingValuation(strategy_id: 'str', asset_id: 'str', quantity: 'Decimal', market_price: 'Decimal', currency: 'str', market_value: 'Decimal', reporting_value: 'Decimal', conversion: 'FxConversion | None', unrealized_pnl: 'Decimal', reporting_unrealized_pnl: 'Decimal') -> None",
      "InstrumentHolding": "class alphalab.portfolio.multi_strategy.InstrumentHolding(asset_id: 'str', currency: 'str', market_price: 'Decimal', net_quantity: 'Decimal', contributions: 'tuple[StrategyContribution, ...]', long_quantity: 'Decimal', short_quantity: 'Decimal', crossed_quantity: 'Decimal') -> None",
      "InstrumentValuation": "class alphalab.portfolio.multi_strategy.InstrumentValuation(holding: 'InstrumentHolding', market_value: 'Decimal', reporting_value: 'Decimal', gross_reporting_value: 'Decimal') -> None",
      "InsufficientFundsError": "class alphalab.portfolio.exceptions.InsufficientFundsError",
      "InvalidTransactionError": "class alphalab.portfolio.exceptions.InvalidTransactionError",
      "MULTI_STRATEGY_BOOK_SCHEME": "value builtins.str",
      "MarginEngine": "class alphalab.portfolio.margin.MarginEngine()",
      "MarketValueUpdated": "class alphalab.portfolio.events.MarketValueUpdated(timestamp: float, account_id: str, prices: collections.abc.Mapping[str, decimal.Decimal]) -> None",
      "MissingRateError": "class alphalab.portfolio.fx.MissingRateError",
      "MixedCurrencyValuationError": "class alphalab.portfolio.exceptions.MixedCurrencyValuationError",
      "MultiStrategyBook": "class alphalab.portfolio.multi_strategy.MultiStrategyBook(portfolio_id: 'str', sleeves: 'tuple[StrategySleeve, ...]', unassigned_cash: 'CurrencyAmounts') -> None",
      "NAVCalculator": "class alphalab.portfolio.nav.NAVCalculator()",
      "NO_RATES": "value alphalab.portfolio.fx.FxRates",
      "PnLEngine": "class alphalab.portfolio.pnl.PnLEngine()",
      "PortfolioEngine": "class alphalab.portfolio.engine.PortfolioEngine()",
      "PortfolioEvent": "class alphalab.portfolio.events.PortfolioEvent(timestamp: float, account_id: str) -> None",
      "PortfolioState": "class alphalab.portfolio.engine.PortfolioState(account: alphalab.portfolio.account.Account, cash: alphalab.portfolio.cash.CashLedger = <factory>, positions: collections.abc.Mapping[str, alphalab.portfolio.position.Position] = <factory>, ledger: alphalab.portfolio.ledger.TransactionLedger = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.portfolio.events.PortfolioEvent] = <factory>, realized_pnl: alphalab.portfolio.amounts.CurrencyAmounts = <factory>, commission_paid: alphalab.portfolio.amounts.CurrencyAmounts = <factory>, pending_marks: tuple[str, ...] = ()) -> None",
      "PortfolioValuation": "class alphalab.portfolio.valuation.PortfolioValuation()",
      "PortfolioValuationSnapshot": "class alphalab.portfolio.valuation.PortfolioValuationSnapshot(timestamp: float, currency: str, cash: decimal.Decimal, long_value: decimal.Decimal, short_value: decimal.Decimal, positions_value: decimal.Decimal, unrealized_pnl: decimal.Decimal, realized_pnl: decimal.Decimal, commission_paid: decimal.Decimal, equity: decimal.Decimal, conversions: tuple[alphalab.portfolio.fx.FxConversion, ...] = ()) -> None",
      "Position": "class alphalab.portfolio.position.Position(asset_id: 'str', quantity: 'Decimal', average_cost: 'Decimal', market_price: 'Decimal', realized_pnl: 'Decimal', currency: 'str', last_updated: 'float', cost_basis: 'Decimal | None' = None, opened_at: 'float | None' = None, minor_units: 'int | None' = None, economics: 'InstrumentEconomics | None' = None) -> None",
      "PositionClosed": "class alphalab.portfolio.events.PositionClosed(timestamp: float, account_id: str, asset_id: str, price: decimal.Decimal, realized_pnl: decimal.Decimal) -> None",
      "PositionIncreased": "class alphalab.portfolio.events.PositionIncreased(timestamp: float, account_id: str, asset_id: str, added_quantity: decimal.Decimal, price: decimal.Decimal) -> None",
      "PositionOpened": "class alphalab.portfolio.events.PositionOpened(timestamp: float, account_id: str, asset_id: str, quantity: decimal.Decimal, price: decimal.Decimal) -> None",
      "PositionReduced": "class alphalab.portfolio.events.PositionReduced(timestamp: float, account_id: str, asset_id: str, reduced_quantity: decimal.Decimal, price: decimal.Decimal, realized_pnl: decimal.Decimal) -> None",
      "PositionSide": "enum alphalab.portfolio.types.PositionSide[LONG, SHORT, FLAT]",
      "PositionSplit": "class alphalab.portfolio.events.PositionSplit(timestamp: float, account_id: str, asset_id: str, ratio: decimal.Decimal, quantity: decimal.Decimal) -> None",
      "SettlementExposure": "class alphalab.portfolio.contracts.SettlementExposure(asset_id: 'str', quoted: 'ContractNotional', settled: 'Decimal', conversion: 'FxConversion | None') -> None",
      "Split": "class alphalab.portfolio.corporate_actions.Split(asset_id: 'str', ratio: 'Decimal') -> None",
      "StaleRateError": "class alphalab.portfolio.fx.StaleRateError",
      "StrategySleeve": "class alphalab.portfolio.multi_strategy.StrategySleeve(strategy_id: 'str', positions: 'Mapping[str, Position]', cash: 'CurrencyAmounts', realized_pnl: 'CurrencyAmounts', commission_paid: 'CurrencyAmounts') -> None",
      "StrategyValuation": "class alphalab.portfolio.multi_strategy.StrategyValuation(strategy_id: 'str', positions: 'int', long_exposure: 'Decimal', short_exposure: 'Decimal', net_exposure: 'Decimal', gross_exposure: 'Decimal', cash: 'Decimal', nav: 'Decimal', unrealized_pnl: 'Decimal', realized_pnl: 'CurrencyAmounts', reporting_realized_pnl: 'Decimal', commission_paid: 'CurrencyAmounts', reporting_commission_paid: 'Decimal') -> None",
      "Transaction": "class alphalab.portfolio.transaction.Transaction(transaction_id: str, timestamp: float, account_id: str, type: alphalab.portfolio.types.TransactionType, asset_id: str, quantity: decimal.Decimal, price: decimal.Decimal, commission: decimal.Decimal, currency: str, metadata: collections.abc.Mapping[str, Any] = <factory>) -> None",
      "TransactionLedger": "class alphalab.portfolio.ledger.TransactionLedger(transactions: alphalab.common.append_log.AppendOnlyLog[alphalab.portfolio.transaction.Transaction] = <factory>) -> None",
      "TransactionType": "enum alphalab.portfolio.types.TransactionType[BUY, SELL, DIVIDEND, DEPOSIT, WITHDRAWAL, FEE, INTEREST, TRANSFER, VARIATION_MARGIN, FUNDING]",
      "VariationSettled": "class alphalab.portfolio.events.VariationSettled(timestamp: float, account_id: str, asset_id: str, price: decimal.Decimal, amount: decimal.Decimal, currency: str) -> None",
      "carry_rate": "function alphalab.portfolio.fx_research.carry_rate(terms: 'ForwardTerms') -> 'float'",
      "cash_in": "function alphalab.portfolio.valuation.cash_in(cash: alphalab.portfolio.cash.CashLedger, base_currency: str, rates: alphalab.portfolio.fx.FxRates, as_of: float | None, units: alphalab.common.currency_units.CurrencyUnits | None = None) -> tuple[decimal.Decimal, tuple[alphalab.portfolio.fx.FxConversion, ...]]",
      "contract_exposures": "function alphalab.portfolio.contracts.contract_exposures(holdings: 'Sequence[ContractHolding]') -> 'ContractExposure'",
      "covered_forward_rate": "function alphalab.portfolio.fx_research.covered_forward_rate(spot: 'FxRate', terms: 'ForwardTerms') -> 'FxRate'",
      "currency_attribution": "function alphalab.portfolio.fx_research.currency_attribution(opening: 'Mapping[str, Decimal]', closing: 'Mapping[str, Decimal]', opening_rates: 'FxRates', closing_rates: 'FxRates', reporting_currency: 'str', opening_timestamp: 'float', closing_timestamp: 'float') -> 'CurrencyAttributionReport'",
      "currency_exposures": "function alphalab.portfolio.fx_research.currency_exposures(positions: 'Mapping[str, Position]') -> 'CurrencyAmounts'",
      "foreign_currencies": "function alphalab.portfolio.valuation.foreign_currencies(cash: alphalab.portfolio.cash.CashLedger, positions: collections.abc.Mapping[str, alphalab.portfolio.position.Position], base_currency: str) -> tuple[tuple[str, ...], tuple[str, ...]]",
      "forward_points": "function alphalab.portfolio.fx_research.forward_points(spot: 'FxRate', forward: 'FxRate') -> 'Decimal'",
      "hedge_notional": "function alphalab.portfolio.fx_research.hedge_notional(exposure: 'Decimal', hedge_ratio: 'Decimal', currency: 'str', units: 'CurrencyUnits' = CurrencyUnits({})) -> 'Decimal'",
      "holding_notional": "function alphalab.portfolio.contracts.holding_notional(holding: 'ContractHolding') -> 'ContractNotional'",
      "settlement_exposures": "function alphalab.portfolio.contracts.settlement_exposures(holdings: 'Sequence[ContractHolding]', rates: 'FxRates', as_of: 'float') -> 'tuple[SettlementExposure, ...]'",
      "value_book": "function alphalab.portfolio.multi_strategy.value_book(book: 'MultiStrategyBook', *, reporting_currency: 'str', rates: 'FxRates', as_of: 'float') -> 'BookValuation'"
    },
    "alphalab.portfolio.fx_feed": {
      "ConflictingQuoteError": "class alphalab.portfolio.fx_feed.ConflictingQuoteError",
      "FX_FEED_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "FX_FEED_SNAPSHOT_SCHEMA": "value builtins.int",
      "FxFeed": "class alphalab.portfolio.fx_feed.FxFeed()",
      "FxFeedDecision": "class alphalab.portfolio.fx_feed.FxFeedDecision(quote: 'FxQuote', outcome: 'FxFeedOutcome', previous: 'FxRate | None' = None) -> None",
      "FxFeedOutcome": "enum alphalab.portfolio.fx_feed.FxFeedOutcome[APPLIED, DUPLICATE, SUPERSEDED]",
      "FxFeedSnapshot": "class alphalab.portfolio.fx_feed.FxFeedSnapshot(feed_id: 'str', max_age_seconds: 'float | None', rates: 'tuple[FxRate, ...]', observed: 'int', applied_count: 'int', last_quote_at: 'float | None', decisions: 'tuple[FxFeedDecision, ...]', schema_version: 'int' = 1) -> None",
      "FxFeedState": "class alphalab.portfolio.fx_feed.FxFeedState(feed_id: 'str', rates: 'FxRates' = <factory>, observed: 'int' = 0, applied_count: 'int' = 0, last_quote_at: 'float | None' = None, decisions: 'AppendOnlyLog[FxFeedDecision]' = <factory>) -> None",
      "FxQuote": "class alphalab.portfolio.fx_feed.FxQuote(rate: 'FxRate', sequence: 'int' = 0) -> None",
      "FxRateSource": "class alphalab.portfolio.fx_feed.FxRateSource(*args, **kwargs)",
      "SequenceFxSource": "class alphalab.portfolio.fx_feed.SequenceFxSource(source_id: 'str', rates: 'tuple[FxRate, ...]' = ()) -> None",
      "capture": "function alphalab.portfolio.fx_feed.capture(state: 'FxFeedState') -> 'FxFeedSnapshot'",
      "from_primitives": "function alphalab.portfolio.fx_feed.from_primitives(payload: 'Mapping[str, Any]') -> 'FxFeedSnapshot'",
      "restore": "function alphalab.portfolio.fx_feed.restore(snapshot: 'FxFeedSnapshot') -> 'FxFeedState'"
    },
    "alphalab.portfolio.snapshot": {
      "PORTFOLIO_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "PORTFOLIO_SNAPSHOT_SCHEMA": "value builtins.int",
      "PortfolioEventRecord": "class alphalab.portfolio.snapshot.PortfolioEventRecord(event_type: 'str', event: 'PortfolioEvent') -> None",
      "PortfolioSnapshot": "class alphalab.portfolio.snapshot.PortfolioSnapshot(account: 'Account', balances: 'Mapping[str, Decimal]', reserved: 'Mapping[str, Decimal]', positions: 'tuple[Position, ...]', transactions: 'tuple[Transaction, ...]', events: 'tuple[PortfolioEventRecord, ...]', realized_pnl: 'Mapping[str, Decimal]', commission_paid: 'Mapping[str, Decimal]', pending_marks: 'tuple[str, ...]', schema_version: 'int' = 5) -> None",
      "capture": "function alphalab.portfolio.snapshot.capture(state: 'PortfolioState') -> 'PortfolioSnapshot'",
      "from_primitives": "function alphalab.portfolio.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'PortfolioSnapshot'",
      "restore": "function alphalab.portfolio.snapshot.restore(snapshot: 'PortfolioSnapshot') -> 'PortfolioState'"
    },
    "alphalab.portfolio_optimizer": {
      "AllocationChanged": "class alphalab.portfolio_optimizer.events.AllocationChanged(event_id: str, timestamp: float, portfolio_id: str, new_capital: float) -> None",
      "AlphaSignalProtocol": "class alphalab.portfolio_optimizer.protocol.AlphaSignalProtocol(*args, **kwargs)",
      "BLACK_LITTERMAN_SCHEME": "value builtins.str",
      "BlackLittermanModel": "class alphalab.portfolio_optimizer.black_litterman.BlackLittermanModel(covariance: 'CovarianceMatrix', prior: 'EquilibriumPrior | SuppliedPrior', tau: 'float', views: 'tuple[InvestorView, ...]') -> None",
      "BlackLittermanPosterior": "class alphalab.portfolio_optimizer.black_litterman.BlackLittermanPosterior(model_id: 'str', prior_returns: 'ExpectedReturns', posterior_returns: 'ExpectedReturns', mean_uncertainty: 'CovarianceMatrix', posterior_covariance: 'CovarianceMatrix', views: 'tuple[ViewDiagnostic, ...]') -> None",
      "BoxUncertainty": "class alphalab.portfolio_optimizer.construction.BoxUncertainty(half_widths: 'Mapping[str, float]') -> None",
      "CONSTRUCTION_PROBLEM_SCHEME": "value builtins.str",
      "CONSTRUCTION_RESULT_SCHEME": "value builtins.str",
      "CapitalAllocation": "class alphalab.portfolio_optimizer.allocation.CapitalAllocation(portfolio_id: str, total_capital: float, invested_capital: float, cash_balance: float, margin_used: float, leverage_ratio: float) -> None",
      "ConstraintSet": "class alphalab.portfolio_optimizer.construction.ConstraintSet(net_exposure: 'ExposureRange', bounds: 'WeightBounds', max_abs_weight: 'float | None' = None, max_gross_exposure: 'float | None' = None, groups: 'tuple[GroupBound, ...]' = (), factors: 'tuple[FactorBound, ...]' = (), turnover: 'TurnoverLimit | None' = None, notional_limits: 'NotionalLimits | None' = None, max_volatility: 'float | None' = None) -> None",
      "ConstraintViolated": "class alphalab.portfolio_optimizer.events.ConstraintViolated(event_id: str, timestamp: float, portfolio_id: str, constraint_name: str, violation_amount: float) -> None",
      "ConstraintViolationError": "class alphalab.portfolio_optimizer.exceptions.ConstraintViolationError",
      "ConstructionDiagnostics": "class alphalab.portfolio_optimizer.construction.ConstructionDiagnostics(method: 'str', iterations: 'int', binding: 'tuple[str, ...]', conflict: 'tuple[str, ...]', max_violation: 'float', stationarity: 'float', covariance_pivot_ratio: 'float', variance: 'float | None', volatility: 'float | None', expected_return: 'float | None', worst_case_return: 'float | None', diversification_ratio: 'float | None', net_exposure: 'float | None', gross_exposure: 'float | None', turnover: 'float | None', risk: 'RiskContributions | None', factor_exposures: 'Mapping[str, float]', group_exposures: 'Mapping[str, float]', budget_deviation: 'float | None', effective_risk_aversion: 'float | None', detail: 'str', transaction_cost: 'float | None' = None) -> None",
      "ConstructionInputError": "class alphalab.portfolio_optimizer.exceptions.ConstructionInputError",
      "ConstructionObjective": "alias ConstructionObjective",
      "ConstructionProblem": "class alphalab.portfolio_optimizer.construction.ConstructionProblem(covariance: 'CovarianceMatrix | FactorStructure', objective: 'ConstructionObjective', constraints: 'ConstraintSet', settings: 'SolverSettings') -> None",
      "ConstructionResult": "class alphalab.portfolio_optimizer.construction.ConstructionResult(problem_id: 'str', status: 'ConstructionStatus', weights: 'Mapping[str, float] | None', diagnostics: 'ConstructionDiagnostics') -> None",
      "ConstructionStatus": "enum alphalab.portfolio_optimizer.construction.ConstructionStatus[OPTIMAL, INFEASIBLE, ITERATION_LIMIT, NUMERICAL_FAILURE]",
      "CostModel": "class alphalab.portfolio_optimizer.costs.CostModel(commission_rate: float, slippage_rate: float, spread_rate: float, market_impact_rate: float, fixed_exchange_fee: float) -> None",
      "EXPECTED_RETURNS_SCHEME": "value builtins.str",
      "EllipsoidalUncertainty": "class alphalab.portfolio_optimizer.construction.EllipsoidalUncertainty(omega: 'CovarianceMatrix', radius: 'float') -> None",
      "EquilibriumPrior": "class alphalab.portfolio_optimizer.black_litterman.EquilibriumPrior(market_values: 'Mapping[str, Decimal]', currency: 'str', risk_aversion: 'float') -> None",
      "ExpectedReturns": "class alphalab.portfolio_optimizer.construction.ExpectedReturns(values: 'Mapping[str, float]', currency: 'str', period: 'str', source: 'str') -> None",
      "ExposureRange": "class alphalab.portfolio_optimizer.construction.ExposureRange(lower: 'float | None', upper: 'float | None') -> None",
      "ExposureUpdated": "class alphalab.portfolio_optimizer.events.ExposureUpdated(event_id: str, timestamp: float, portfolio_id: str) -> None",
      "FactorBound": "class alphalab.portfolio_optimizer.construction.FactorBound(loadings: 'FactorLoadings', factor: 'str', lower: 'float | None', upper: 'float | None') -> None",
      "GroupBound": "class alphalab.portfolio_optimizer.construction.GroupBound(classification: 'Classification', label: 'str', lower: 'float | None', upper: 'float | None') -> None",
      "InvalidPortfolioStateError": "class alphalab.portfolio_optimizer.exceptions.InvalidPortfolioStateError",
      "InvestorView": "class alphalab.portfolio_optimizer.black_litterman.InvestorView(name: 'str', exposures: 'Mapping[str, float]', expected_return: 'float', variance: 'float') -> None",
      "LinearCosts": "class alphalab.portfolio_optimizer.construction.LinearCosts(current: 'Mapping[str, float]', rates: 'Mapping[str, float]') -> None",
      "LotRounding": "class alphalab.portfolio_optimizer.lots.LotRounding(quantities: 'Mapping[str, Decimal]', notionals: 'Mapping[str, Decimal]', weights: 'Mapping[str, float]', residuals: 'Mapping[str, float]', below_one_lot: 'tuple[str, ...]') -> None",
      "MaximumDiversification": "class alphalab.portfolio_optimizer.construction.MaximumDiversification() -> None",
      "MeanVariance": "class alphalab.portfolio_optimizer.construction.MeanVariance(expected_returns: 'ExpectedReturns', risk_aversion: 'float', costs: 'LinearCosts | None' = None) -> None",
      "MinimumVariance": "class alphalab.portfolio_optimizer.construction.MinimumVariance() -> None",
      "NotionalLimits": "class alphalab.portfolio_optimizer.construction.NotionalLimits(capital: 'Decimal', maximum_notional: 'Mapping[str, Decimal]') -> None",
      "OptimizationError": "class alphalab.portfolio_optimizer.exceptions.OptimizationError",
      "Portfolio": "class alphalab.portfolio_optimizer.targets.Portfolio(portfolio_id: str, name: str, base_currency: str, created_at: float, is_active: bool = True) -> None",
      "PortfolioAdapter": "class alphalab.portfolio_optimizer.adapter.PortfolioAdapter()",
      "PortfolioCreated": "class alphalab.portfolio_optimizer.events.PortfolioCreated(event_id: str, timestamp: float, portfolio_id: str) -> None",
      "PortfolioEngine": "class alphalab.portfolio_optimizer.engine.PortfolioEngine()",
      "PortfolioEngineError": "class alphalab.portfolio_optimizer.exceptions.PortfolioEngineError",
      "PortfolioEngineState": "class alphalab.portfolio_optimizer.state.PortfolioEngineState(engine_id: str, portfolios: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.targets.Portfolio] = <factory>, weights: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.weights.TargetWeights] = <factory>, constraints: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.constraints.WeightConstraints] = <factory>, metrics: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.metrics.PortfolioMetrics] = <factory>, exposures: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.exposure.PortfolioExposure] = <factory>, allocations: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.allocation.CapitalAllocation] = <factory>, cost_estimates: alphalab.common.persistent_map.PersistentMap[str, alphalab.portfolio_optimizer.costs.TransactionCostEstimate] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.portfolio_optimizer.events.PortfolioEvent] = <factory>) -> None",
      "PortfolioEvent": "class alphalab.portfolio_optimizer.events.PortfolioEvent(event_id: str, timestamp: float) -> None",
      "PortfolioExposure": "class alphalab.portfolio_optimizer.exposure.PortfolioExposure(portfolio_id: str, timestamp: float, sector_exposure: collections.abc.Mapping[str, float] = <factory>, country_exposure: collections.abc.Mapping[str, float] = <factory>, factor_exposure: collections.abc.Mapping[str, float] = <factory>, net_beta: float = 0.0, gross_exposure: float = 0.0, net_exposure: float = 0.0) -> None",
      "PortfolioMetrics": "class alphalab.portfolio_optimizer.metrics.PortfolioMetrics(portfolio_id: str, timestamp: float, total_return: float, annual_return: float, volatility: float, sharpe_ratio: float, sortino_ratio: float, calmar_ratio: float, max_drawdown: float, turnover: float, diversification_ratio: float) -> None",
      "PortfolioUpdated": "class alphalab.portfolio_optimizer.events.PortfolioUpdated(event_id: str, timestamp: float, portfolio_id: str) -> None",
      "PortfolioValidationError": "class alphalab.portfolio_optimizer.exceptions.PortfolioValidationError",
      "RebalanceTrigger": "enum alphalab.portfolio_optimizer.rebalance.RebalanceTrigger[DAILY, WEEKLY, MONTHLY, THRESHOLD, VOLATILITY, CUSTOM]",
      "Rebalanced": "class alphalab.portfolio_optimizer.events.Rebalanced(event_id: str, timestamp: float, portfolio_id: str, trigger: str) -> None",
      "RiskConstraints": "class alphalab.portfolio_optimizer.constraints.RiskConstraints(max_drawdown_limit: float, max_volatility_limit: float, max_turnover: float) -> None",
      "RiskModelProtocol": "class alphalab.portfolio_optimizer.protocol.RiskModelProtocol(*args, **kwargs)",
      "RiskParity": "class alphalab.portfolio_optimizer.construction.RiskParity(budgets: 'Mapping[str, Decimal] | None') -> None",
      "RobustMeanVariance": "class alphalab.portfolio_optimizer.construction.RobustMeanVariance(expected_returns: 'ExpectedReturns', risk_aversion: 'float', uncertainty: 'EllipsoidalUncertainty | BoxUncertainty') -> None",
      "SolverSettings": "class alphalab.portfolio_optimizer.construction.SolverSettings(feasibility_tolerance: 'float', convergence_tolerance: 'float', max_iterations: 'int') -> None",
      "SuppliedPrior": "class alphalab.portfolio_optimizer.black_litterman.SuppliedPrior(returns: 'ExpectedReturns') -> None",
      "TargetTransaction": "class alphalab.portfolio_optimizer.transactions.TargetTransaction(symbol: str, current_weight: float, target_weight: float, trade_weight: float, estimated_cost: float) -> None",
      "TargetWeights": "class alphalab.portfolio_optimizer.weights.TargetWeights(portfolio_id: str, timestamp: float, weights: collections.abc.Mapping[str, float] = <factory>) -> None",
      "TransactionCostEstimate": "class alphalab.portfolio_optimizer.costs.TransactionCostEstimate(portfolio_id: str, total_trade_value: float, estimated_commission: float, estimated_slippage: float, estimated_market_impact: float, total_estimated_cost: float, estimated_spread: float = 0.0) -> None",
      "TurnoverLimit": "class alphalab.portfolio_optimizer.construction.TurnoverLimit(current: 'Mapping[str, float]', maximum: 'float') -> None",
      "ViewDiagnostic": "class alphalab.portfolio_optimizer.black_litterman.ViewDiagnostic(name: 'str', stated: 'float', prior_implied: 'float', posterior_implied: 'float', variance: 'float') -> None",
      "WeightBounds": "class alphalab.portfolio_optimizer.construction.WeightBounds(lower: 'float | None', upper: 'float | None', overrides: 'Mapping[str, tuple[float | None, float | None]]' = <factory>) -> None",
      "WeightConstraints": "class alphalab.portfolio_optimizer.constraints.WeightConstraints(long_only: bool = True, max_position_weight: float = 1.0, min_position_weight: float = -1.0, cash_reserve_weight: float = 0.0, max_sector_exposure: collections.abc.Mapping[str, float] = <factory>, max_asset_exposure: float = 1.0) -> None",
      "WeightsCalculated": "class alphalab.portfolio_optimizer.events.WeightsCalculated(event_id: str, timestamp: float, portfolio_id: str, optimization_method: str) -> None",
      "allocation_report": "function alphalab.portfolio_optimizer.views.allocation_report(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, port_id: str) -> alphalab.portfolio_optimizer.allocation.CapitalAllocation | None",
      "apply_weight_constraints": "function alphalab.portfolio_optimizer.constraints.apply_weight_constraints(raw_weights: collections.abc.Mapping[str, float], constraints: alphalab.portfolio_optimizer.constraints.WeightConstraints) -> dict[str, float]",
      "black_litterman": "function alphalab.portfolio_optimizer.black_litterman.black_litterman(model: 'BlackLittermanModel') -> 'BlackLittermanPosterior'",
      "calculate_max_drawdown": "function alphalab.common.statistics.compounded_max_drawdown(returns: 'Sequence[float]') -> 'float'",
      "check_schedule_rebalance": "function alphalab.portfolio_optimizer.rebalance.check_schedule_rebalance(last_rebalance: float, current_time: float, trigger: alphalab.portfolio_optimizer.rebalance.RebalanceTrigger) -> bool",
      "check_threshold_rebalance": "function alphalab.portfolio_optimizer.rebalance.check_threshold_rebalance(current_weights: collections.abc.Mapping[str, float], target_weights: collections.abc.Mapping[str, float], threshold: float = 0.05) -> bool",
      "construct": "function alphalab.portfolio_optimizer.construction.construct(problem: 'ConstructionProblem') -> 'ConstructionResult'",
      "expected_costs": "function alphalab.portfolio_optimizer.views.expected_costs(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, port_id: str) -> alphalab.portfolio_optimizer.costs.TransactionCostEstimate | None",
      "exposure_report": "function alphalab.portfolio_optimizer.views.exposure_report(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, port_id: str) -> alphalab.portfolio_optimizer.exposure.PortfolioExposure | None",
      "optimize_equal_weight": "function alphalab.portfolio_optimizer.optimizer.optimize_equal_weight(symbols: collections.abc.Sequence[str]) -> dict[str, float]",
      "optimize_inverse_volatility": "function alphalab.portfolio_optimizer.optimizer.optimize_inverse_volatility(symbols: collections.abc.Sequence[str], volatilities: collections.abc.Mapping[str, float]) -> dict[str, float]",
      "optimize_maximum_sharpe": "function alphalab.portfolio_optimizer.optimizer.optimize_maximum_sharpe(symbols: collections.abc.Sequence[str], expected_returns: collections.abc.Sequence[float], covariance_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]) -> dict[str, float]",
      "optimize_minimum_variance": "function alphalab.portfolio_optimizer.optimizer.optimize_minimum_variance(symbols: collections.abc.Sequence[str], covariance_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]) -> dict[str, float]",
      "portfolio_metrics": "function alphalab.portfolio_optimizer.views.portfolio_metrics(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, port_id: str) -> alphalab.portfolio_optimizer.metrics.PortfolioMetrics | None",
      "portfolio_summary": "function alphalab.portfolio_optimizer.views.portfolio_summary(state: alphalab.portfolio_optimizer.state.PortfolioEngineState) -> collections.abc.Sequence[alphalab.portfolio_optimizer.targets.Portfolio]",
      "round_to_lots": "function alphalab.portfolio_optimizer.lots.round_to_lots(weights: 'Mapping[str, float]', *, capital: 'Decimal', prices: 'Mapping[str, Decimal]', economics: 'Mapping[str, InstrumentEconomics]', quantum: 'Decimal') -> 'LotRounding'",
      "validate_portfolio_creation": "function alphalab.portfolio_optimizer.validation.validate_portfolio_creation(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, portfolio: alphalab.portfolio_optimizer.targets.Portfolio) -> None",
      "validate_portfolio_exists": "function alphalab.portfolio_optimizer.validation.validate_portfolio_exists(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, portfolio_id: str) -> None",
      "validate_risk_constraints": "function alphalab.portfolio_optimizer.risk.validate_risk_constraints(metrics: alphalab.portfolio_optimizer.metrics.PortfolioMetrics, constraints: alphalab.portfolio_optimizer.constraints.RiskConstraints) -> None",
      "view_variance_from_prior": "function alphalab.portfolio_optimizer.black_litterman.view_variance_from_prior(exposures: 'Mapping[str, float]', covariance: 'CovarianceMatrix', tau: 'float', scale: 'float') -> 'float'",
      "weight_breakdown": "function alphalab.portfolio_optimizer.views.weight_breakdown(state: alphalab.portfolio_optimizer.state.PortfolioEngineState, port_id: str) -> alphalab.portfolio_optimizer.weights.TargetWeights | None"
    },
    "alphalab.reinforcement_learning": {
      "Action": "enum alphalab.reinforcement_learning.action.Action[HOLD, BUY, SELL]",
      "QTable": "class alphalab.reinforcement_learning.q_learning.QTable(values: collections.abc.Mapping[tuple[tuple[str, str], alphalab.reinforcement_learning.action.Action], float] = <factory>) -> None",
      "RLAgentStrategy": "class alphalab.reinforcement_learning.environment.RLAgentStrategy()",
      "RLError": "class alphalab.reinforcement_learning.exceptions.RLError",
      "RLInputError": "class alphalab.reinforcement_learning.exceptions.RLInputError",
      "State": "alias tuple[str, str]",
      "StepResult": "class alphalab.reinforcement_learning.environment.StepResult(state: alphalab.reinforcement_learning.environment.TradingEnvState, reward: decimal.Decimal, done: bool, info: collections.abc.Mapping[str, Any]) -> None",
      "TradingEnvConfig": "class alphalab.reinforcement_learning.environment.TradingEnvConfig(asset_id: str, strategy_id: str, trade_size: decimal.Decimal, starting_cash: decimal.Decimal, currency: str) -> None",
      "TradingEnvState": "class alphalab.reinforcement_learning.environment.TradingEnvState(config: alphalab.reinforcement_learning.environment.TradingEnvConfig, pipeline: alphalab.runtime.execution_pipeline.ExecutionPipelineState, equity: decimal.Decimal, step_count: int) -> None",
      "Trajectory": "class alphalab.reinforcement_learning.policy.Trajectory(states: tuple[tuple[float, ...], ...], actions: tuple[int, ...], rewards: tuple[float, ...]) -> None",
      "action_to_signed_quantity": "function alphalab.reinforcement_learning.action.action_to_signed_quantity(action: alphalab.reinforcement_learning.action.Action, trade_size: decimal.Decimal) -> decimal.Decimal",
      "average_reward": "function alphalab.reinforcement_learning.evaluation.average_reward(rewards: tuple[float, ...]) -> float",
      "best_action": "function alphalab.reinforcement_learning.q_learning.best_action(table: alphalab.reinforcement_learning.q_learning.QTable, state: tuple[str, str], actions: tuple[alphalab.reinforcement_learning.action.Action, ...] = (<Action.HOLD: 1>, <Action.BUY: 2>, <Action.SELL: 3>)) -> alphalab.reinforcement_learning.action.Action",
      "create_environment": "function alphalab.reinforcement_learning.environment.create_environment(config: alphalab.reinforcement_learning.environment.TradingEnvConfig, timestamp: float) -> alphalab.reinforcement_learning.environment.TradingEnvState",
      "cumulative_reward": "function alphalab.reinforcement_learning.evaluation.cumulative_reward(rewards: tuple[float, ...]) -> float",
      "current_position": "function alphalab.reinforcement_learning.environment.current_position(state: alphalab.reinforcement_learning.environment.TradingEnvState) -> decimal.Decimal",
      "discounted_returns": "function alphalab.reinforcement_learning.policy.discounted_returns(rewards: tuple[float, ...], discount: float) -> tuple[float, ...]",
      "discretize_state": "function alphalab.reinforcement_learning.q_learning.discretize_state(position: decimal.Decimal, price_change_pct: decimal.Decimal) -> tuple[str, str]",
      "max_drawdown": "function alphalab.reinforcement_learning.evaluation.max_drawdown(rewards: tuple[float, ...]) -> float",
      "policy_probabilities": "function alphalab.reinforcement_learning.policy.policy_probabilities(network: alphalab.deep_learning.network.Sequential, state: tuple[float, ...]) -> tuple[float, ...]",
      "q_update": "function alphalab.reinforcement_learning.q_learning.q_update(table: alphalab.reinforcement_learning.q_learning.QTable, state: tuple[str, str], action: alphalab.reinforcement_learning.action.Action, reward: float, next_state: tuple[str, str], learning_rate: float, discount: float, actions: tuple[alphalab.reinforcement_learning.action.Action, ...] = (<Action.HOLD: 1>, <Action.BUY: 2>, <Action.SELL: 3>)) -> alphalab.reinforcement_learning.q_learning.QTable",
      "q_value": "function alphalab.reinforcement_learning.q_learning.q_value(table: alphalab.reinforcement_learning.q_learning.QTable, state: tuple[str, str], action: alphalab.reinforcement_learning.action.Action) -> float",
      "reinforce_update": "function alphalab.reinforcement_learning.policy.reinforce_update(network: alphalab.deep_learning.network.Sequential, trajectory: alphalab.reinforcement_learning.policy.Trajectory, learning_rate: float, discount: float) -> tuple[alphalab.deep_learning.network.Sequential, float]",
      "reward_volatility": "function alphalab.reinforcement_learning.evaluation.reward_volatility(rewards: tuple[float, ...]) -> float",
      "sample_action": "function alphalab.reinforcement_learning.policy.sample_action(probabilities: tuple[float, ...], rng: random.Random) -> int",
      "sharpe_like_ratio": "function alphalab.reinforcement_learning.evaluation.sharpe_like_ratio(rewards: tuple[float, ...]) -> float",
      "step_environment": "function alphalab.reinforcement_learning.environment.step_environment(state: alphalab.reinforcement_learning.environment.TradingEnvState, action: alphalab.reinforcement_learning.action.Action, price: decimal.Decimal, timestamp: float) -> alphalab.reinforcement_learning.environment.StepResult",
      "win_rate": "function alphalab.reinforcement_learning.evaluation.win_rate(rewards: tuple[float, ...]) -> float"
    },
    "alphalab.replay": {
      "DataLoaderProtocol": "class alphalab.replay.loader.DataLoaderProtocol(*args, **kwargs)",
      "HistoricalEventProtocol": "class alphalab.replay.loader.HistoricalEventProtocol(*args, **kwargs)",
      "InvalidReplayStateError": "class alphalab.replay.exceptions.InvalidReplayStateError",
      "ReplayAdvanced": "class alphalab.replay.events.ReplayAdvanced(event_id: str, timestamp: float, old_timestamp: float, new_timestamp: float, events_yielded: int) -> None",
      "ReplayBatchResult": "class alphalab.replay.replay.ReplayBatchResult(state: alphalab.replay.state.ReplayState, events: tuple[alphalab.replay.loader.HistoricalEventProtocol, ...]) -> None",
      "ReplayCompleted": "class alphalab.replay.events.ReplayCompleted(event_id: str, timestamp: float, session_id: str) -> None",
      "ReplayEngine": "class alphalab.replay.engine.ReplayEngine()",
      "ReplayError": "class alphalab.replay.exceptions.ReplayError",
      "ReplayMetrics": "class alphalab.replay.metrics.ReplayMetrics(events_processed: int, total_events: int, elapsed_replay_time: float, elapsed_real_time: float) -> None",
      "ReplayPaused": "class alphalab.replay.events.ReplayPaused(event_id: str, timestamp: float, session_id: str) -> None",
      "ReplayReset": "class alphalab.replay.events.ReplayReset(event_id: str, timestamp: float, reset_time: float) -> None",
      "ReplayResumed": "class alphalab.replay.events.ReplayResumed(event_id: str, timestamp: float, session_id: str) -> None",
      "ReplaySession": "class alphalab.replay.session.ReplaySession(session_id: str, start_time: float, end_time: float, speed_multiplier: float = 1.0) -> None",
      "ReplayStarted": "class alphalab.replay.events.ReplayStarted(event_id: str, timestamp: float, session_id: str, total_events: int) -> None",
      "ReplayState": "class alphalab.replay.state.ReplayState(session: alphalab.replay.session.ReplaySession, status: alphalab.replay.state.ReplayStatus, events: tuple[alphalab.replay.loader.HistoricalEventProtocol, ...], current_index: int, current_timestamp: float, real_start_time: float, real_current_time: float, system_events: alphalab.common.append_log.AppendOnlyLog[alphalab.replay.events.ReplaySystemEvent] = <factory>) -> None",
      "ReplayStatus": "enum alphalab.replay.state.ReplayStatus[READY, RUNNING, PAUSED, STOPPED, COMPLETED]",
      "ReplayStepResult": "class alphalab.replay.replay.ReplayStepResult(state: alphalab.replay.state.ReplayState, event: alphalab.replay.loader.HistoricalEventProtocol | None) -> None",
      "ReplayStopped": "class alphalab.replay.events.ReplayStopped(event_id: str, timestamp: float, session_id: str) -> None",
      "ReplaySystemEvent": "class alphalab.replay.events.ReplaySystemEvent(event_id: str, timestamp: float) -> None",
      "ReplayValidationError": "class alphalab.replay.exceptions.ReplayValidationError",
      "completion_ratio": "function alphalab.replay.views.completion_ratio(state: alphalab.replay.state.ReplayState) -> decimal.Decimal",
      "current_throughput": "function alphalab.replay.views.current_throughput(state: alphalab.replay.state.ReplayState) -> float",
      "current_timestamp": "function alphalab.replay.views.current_timestamp(state: alphalab.replay.state.ReplayState) -> float",
      "elapsed_real_time": "function alphalab.replay.views.elapsed_real_time(state: alphalab.replay.state.ReplayState) -> float",
      "processed_events": "function alphalab.replay.views.processed_events(state: alphalab.replay.state.ReplayState) -> int",
      "remaining_events": "function alphalab.replay.views.remaining_events(state: alphalab.replay.state.ReplayState) -> int",
      "validate_events": "function alphalab.replay.validation.validate_events(events: tuple[alphalab.replay.loader.HistoricalEventProtocol, ...]) -> None",
      "validate_session": "function alphalab.replay.validation.validate_session(session: alphalab.replay.session.ReplaySession) -> None"
    },
    "alphalab.reporting": {
      "ExportCompleted": "class alphalab.reporting.events.ExportCompleted(event_id: str, timestamp: float, report_id: str, export_format: str, byte_size: int) -> None",
      "ExportError": "class alphalab.reporting.exceptions.ExportError",
      "ExportFailed": "class alphalab.reporting.events.ExportFailed(event_id: str, timestamp: float, report_id: str, export_format: str, reason: str) -> None",
      "ExportProtocol": "class alphalab.reporting.protocol.ExportProtocol(*args, **kwargs)",
      "Report": "class alphalab.reporting.report.Report(report_id: str, title: str, timestamp: float, report_type: alphalab.reporting.report.ReportType, sections: tuple[alphalab.reporting.sections.ReportSection, ...], summary: str = '', metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "ReportGenerated": "class alphalab.reporting.events.ReportGenerated(event_id: str, timestamp: float, report_id: str, report_type: str) -> None",
      "ReportSection": "class alphalab.reporting.sections.ReportSection(name: str, section_type: alphalab.reporting.sections.ReportSectionType, content: Any, description: str = '') -> None",
      "ReportSectionType": "enum alphalab.reporting.sections.ReportSectionType[TEXT, METRICS, TABLE, CHART_METADATA]",
      "ReportType": "enum alphalab.reporting.report.ReportType[PERFORMANCE, RISK, PORTFOLIO, TRADE, EXECUTION, OPTIMIZATION, RUNTIME]",
      "ReportingAdapter": "class alphalab.reporting.adapter.ReportingAdapter()",
      "ReportingEngine": "class alphalab.reporting.engine.ReportingEngine()",
      "ReportingError": "class alphalab.reporting.exceptions.ReportingError",
      "ReportingEvent": "class alphalab.reporting.events.ReportingEvent(event_id: str, timestamp: float) -> None",
      "ReportingState": "class alphalab.reporting.state.ReportingState(engine_id: str, reports: alphalab.common.persistent_map.PersistentMap[str, alphalab.reporting.report.Report] = <factory>, exports: alphalab.common.persistent_map.PersistentMap[str, str] = <factory>, statistics: alphalab.reporting.state.ReportingStatistics = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.reporting.events.ReportingEvent] = <factory>, metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "ReportingStatistics": "class alphalab.reporting.state.ReportingStatistics(total_reports_generated: int = 0, total_exports_completed: int = 0, total_exports_failed: int = 0) -> None",
      "ReportingValidationError": "class alphalab.reporting.exceptions.ReportingValidationError",
      "export_csv": "function alphalab.reporting.export.export_csv(report: alphalab.reporting.report.Report) -> str",
      "export_json": "function alphalab.reporting.export.export_json(report: alphalab.reporting.report.Report) -> str",
      "export_markdown": "function alphalab.reporting.export.export_markdown(report: alphalab.reporting.report.Report) -> str",
      "export_statistics": "function alphalab.reporting.views.export_statistics(state: alphalab.reporting.state.ReportingState) -> alphalab.reporting.state.ReportingStatistics",
      "get_export": "function alphalab.reporting.views.get_export(state: alphalab.reporting.state.ReportingState, report_id: str, format_type: str) -> str | None",
      "latest_report": "function alphalab.reporting.views.latest_report(state: alphalab.reporting.state.ReportingState) -> alphalab.reporting.report.Report | None",
      "report_count": "function alphalab.reporting.views.report_count(state: alphalab.reporting.state.ReportingState) -> int",
      "validate_report": "function alphalab.reporting.validation.validate_report(state: alphalab.reporting.state.ReportingState, report: alphalab.reporting.report.Report) -> None"
    },
    "alphalab.research": {
      "AbnormalReturnModel": "enum alphalab.research.event_study.AbnormalReturnModel[RAW, MARKET_ADJUSTED, MEAN_ADJUSTED]",
      "AnalysisCompleted": "class alphalab.research.events.AnalysisCompleted(event_id: str, timestamp: float, research_id: str, analysis_type: str) -> None",
      "BiasReport": "class alphalab.research.bias.BiasReport(win_rate: float | None, mean_trade_duration_seconds: float | None, annualized_volatility: float | None, parameter_count: int, trade_count: int, observations: int, trades_per_parameter: float | None) -> None",
      "BootstrapReport": "class alphalab.research.bootstrap.BootstrapReport(metric: str, iterations: int, lower_bound_5th: float | None, median_50th: float | None, upper_bound_95th: float | None) -> None",
      "CVMethod": "enum alphalab.research.time_series_cv.CVMethod[ROLLING, EXPANDING, PURGED, EMBARGOED]",
      "CapacityReport": "class alphalab.research.capacity.CapacityReport(base_aum: float, base_cagr: float | None, trade_count: int, trades_per_year: float | None) -> None",
      "CompositeRule": "class alphalab.research.regimes.CompositeRule(components: 'tuple[ComponentRule, ...]', cells: 'tuple[RegimeCell, ...]') -> None",
      "Correction": "enum alphalab.research.multiple_testing.Correction[BONFERRONI, HOLM, BENJAMINI_HOCHBERG, BENJAMINI_YEKUTIELI]",
      "DeflatedSharpe": "class alphalab.research.sharpe_inference.DeflatedSharpe(inference: 'SharpeInference', independent_trials: 'int', trial_sharpe_variance: 'float', expected_maximum: 'float') -> None",
      "DiagnosticReport": "class alphalab.research.diagnostics.DiagnosticReport(too_few_trades: bool, high_concentration: bool, large_tail_risk: bool, warnings: tuple[str, ...]) -> None",
      "DiagnosticsGenerated": "class alphalab.research.events.DiagnosticsGenerated(event_id: str, timestamp: float, research_id: str, warning_count: int) -> None",
      "EVENT_STUDY_SCHEME": "value builtins.str",
      "ErrorRate": "enum alphalab.research.multiple_testing.ErrorRate[FAMILY_WISE, FALSE_DISCOVERY]",
      "EventOutcome": "class alphalab.research.event_study.EventOutcome(event_id: 'str', subject: 'str', event_type: 'str', known_at: 'float', tradable_at: 'float', timing: 'SessionTiming', anchor: 'float', abnormal_returns: 'tuple[float, ...]', cumulative: 'float', pre_event: 'float', post_event: 'float') -> None",
      "EventStudyDefinition": "class alphalab.research.event_study.EventStudyDefinition(name: 'str', event_types: 'tuple[str, ...]', window: 'EventWindow', model: 'AbnormalReturnModel', benchmark: 'str | None', visibility: 'VisibilityRule') -> None",
      "EventStudyResult": "class alphalab.research.event_study.EventStudyResult(definition: 'EventStudyDefinition', event_set_version: 'str', prices_version: 'str | None', calendar_id: 'str', outcomes: 'tuple[EventOutcome, ...]', excluded: 'tuple[ExcludedEvent, ...]', average_abnormal: 'tuple[float, ...]', mean_cumulative: 'float', median_cumulative: 'float', cumulative_std: 'float | None', positive_share: 'float', shared_anchor_events: 'int', result_id: 'str') -> None",
      "EventWindow": "class alphalab.research.event_study.EventWindow(before: 'int', after: 'int', estimation: 'int', gap: 'int') -> None",
      "ExcludedEvent": "class alphalab.research.event_study.ExcludedEvent(event_id: 'str', subject: 'str', reason: 'str') -> None",
      "FoldSelection": "class alphalab.research.walk_forward_optimization.FoldSelection(fold: 'int', selected: 'str', parameters: 'Mapping[str, ParamValue]', position: 'int', surface: 'SweepResult', validation_score: 'float', test_score: 'float', degradation: 'float | None') -> None",
      "InvalidResearchStateError": "class alphalab.research.exceptions.InvalidResearchStateError",
      "MonteCarloReport": "class alphalab.research.montecarlo.MonteCarloReport(simulations: int, median_drawdown: float | None, percentile_95_drawdown: float | None, worst_drawdown: float | None, ruin_drawdown: float, ruin_probability: float | None) -> None",
      "MultipleTestingResult": "class alphalab.research.multiple_testing.MultipleTestingResult(correction: 'Correction', alpha: 'float', p_values: 'Mapping[str, float]', adjusted: 'Mapping[str, float]', rejected: 'tuple[str, ...]') -> None",
      "OverfittingPolicy": "class alphalab.research.overfitting.OverfittingPolicy(maximum_degradation: 'float | None' = None, maximum_sensitivity: 'float | None' = None, maximum_neighbour_drop: 'float | None' = None, minimum_positive_share: 'float | None' = None, alpha: 'float' = 0.05) -> None",
      "OverfittingReport": "class alphalab.research.overfitting.OverfittingReport(metric: 'str', trials: 'int', in_sample: 'float', out_of_sample: 'float', degradation: 'float | None', sensitivity: 'float | None', neighbour_drop: 'float | None', effective_parameters: 'int', policy: 'OverfittingPolicy', period: 'StabilityReport | None' = None, symbol: 'StabilityReport | None' = None, findings: 'tuple[str, ...]' = <factory>) -> None",
      "ParameterSpace": "class alphalab.research.walk_forward_optimization.ParameterSpace(candidates: 'tuple[Mapping[str, ParamValue], ...]') -> None",
      "Perturbation": "class alphalab.research.perturbation.Perturbation(kind: 'PerturbationKind', magnitude: 'float', seed: 'int | None' = None, detail: 'str' = '') -> None",
      "PerturbationKind": "enum alphalab.research.perturbation.PerturbationKind[PARAMETER, DATA, SIGNAL, MISSING_DATA, EXECUTION_DELAY, EXECUTION_COST, BLOCK_BOOTSTRAP, MONTE_CARLO]",
      "PerturbationRun": "class alphalab.research.perturbation.PerturbationRun(perturbation: 'Perturbation', baseline: 'str', dataset_version: 'str | None', metrics: 'Mapping[str, float]' = <factory>, baseline_metrics: 'Mapping[str, float]' = <factory>) -> None",
      "PurgePolicy": "class alphalab.research.purging.PurgePolicy(label_ends: 'Mapping[float, float]', embargo_seconds: 'float' = 0.0) -> None",
      "PurgeResult": "class alphalab.research.purging.PurgeResult(kept: 'tuple[float, ...]', purged: 'tuple[float, ...]', embargoed: 'tuple[float, ...]') -> None",
      "QuantileBucket": "class alphalab.research.signals.QuantileBucket(bucket: 'int', observations: 'int', instants: 'int', mean_forward_return: 'float', median_forward_return: 'float') -> None",
      "REGIME_DEFINITION_SCHEME": "value builtins.str",
      "REGIME_SERIES_SCHEME": "value builtins.str",
      "RESULT_KEY_SCHEME": "value builtins.str",
      "Refit": "enum alphalab.research.walk_forward_optimization.Refit[TRAIN, TRAIN_AND_VALIDATION]",
      "RegimeCell": "class alphalab.research.regimes.RegimeCell(components: 'tuple[str, ...]', regime: 'str') -> None",
      "RegimeDefinition": "class alphalab.research.regimes.RegimeDefinition(name: 'str', rule: 'RegimeRule', persistence: 'int') -> None",
      "RegimeProfile": "class alphalab.research.regimes.RegimeProfile(series_id: 'str', classified: 'int', unclassified: 'int', statistics: 'tuple[RegimeStatistics, ...]', transitions: 'tuple[TransitionFrequency, ...]') -> None",
      "RegimeReport": "class alphalab.research.regime.RegimeReport(observations_by_regime: collections.abc.Mapping[str, int], sharpe_by_regime: collections.abc.Mapping[str, float]) -> None",
      "RegimeRule": "alias RegimeRule",
      "RegimeSeries": "class alphalab.research.regimes.RegimeSeries(definition: 'RegimeDefinition', input_id: 'str | None', initial_state_id: 'str', timestamps: 'tuple[float, ...]', raw_labels: 'tuple[str | None, ...]', regimes: 'tuple[str | None, ...]', transitions: 'tuple[RegimeTransition, ...]', final_state: 'RegimeState') -> None",
      "RegimeState": "class alphalab.research.regimes.RegimeState(definition_id: 'str', observations: 'int', last_timestamp: 'float | None', regime: 'str | None', candidate: 'str | None', candidate_count: 'int', windows: 'tuple[tuple[str, tuple[float, ...]], ...]') -> None",
      "RegimeStatistics": "class alphalab.research.regimes.RegimeStatistics(label: 'str', observations: 'int', share: 'float', spells: 'int', mean_duration: 'float', mean_return: 'float | None', return_std: 'float | None', return_observations: 'int') -> None",
      "RegimeTransition": "class alphalab.research.regimes.RegimeTransition(at: 'float', index: 'int', previous: 'str | None', current: 'str') -> None",
      "ResearchAdapter": "class alphalab.research.adapter.ResearchAdapter()",
      "ResearchCompleted": "class alphalab.research.events.ResearchCompleted(event_id: str, timestamp: float, research_id: str, metric_count: int, finding_count: int) -> None",
      "ResearchEngine": "class alphalab.research.engine.ResearchEngine()",
      "ResearchError": "class alphalab.research.exceptions.ResearchError",
      "ResearchEvent": "class alphalab.research.events.ResearchEvent(event_id: str, timestamp: float) -> None",
      "ResearchPayload": "class alphalab.research.protocol.ResearchPayload(strategy_id: str, returns: tuple[float, ...], trades: tuple[alphalab.research.protocol.TradePayload, ...], parameters: collections.abc.Mapping[str, float], market_regimes: tuple[str, ...], aum: float, periods_per_year: int, risk_free_rate: float, sweep: alphalab.research.overfitting.SweepResult | None = None) -> None",
      "ResearchPolicy": "class alphalab.research.research.ResearchPolicy(walk_forward_windows: int, ruin_drawdown: float, minimum_trades: int, maximum_trade_share: float, worst_period_return: float, shock_return: float, gain_multiplier: float, loss_multiplier: float) -> None",
      "ResearchProtocol": "class alphalab.research.protocol.ResearchProtocol(*args, **kwargs)",
      "ResearchStarted": "class alphalab.research.events.ResearchStarted(event_id: str, timestamp: float, research_id: str, strategy_id: str) -> None",
      "ResearchState": "class alphalab.research.state.ResearchState(research_id: str, strategy_id: str, timestamp: float, completed: bool = False, bias_report: alphalab.research.bias.BiasReport | None = None, walk_forward_report: alphalab.research.cross_validation.WalkForwardReport | None = None, monte_carlo_report: alphalab.research.montecarlo.MonteCarloReport | None = None, bootstrap_report: alphalab.research.bootstrap.BootstrapReport | None = None, robustness_report: alphalab.research.sensitivity.RobustnessReport | None = None, regime_report: alphalab.research.regime.RegimeReport | None = None, capacity_report: alphalab.research.capacity.CapacityReport | None = None, stress_report: alphalab.research.stress.StressReport | None = None, diagnostic_report: alphalab.research.diagnostics.DiagnosticReport | None = None, policy: alphalab.research.research.ResearchPolicy | None = None, metrics: collections.abc.Mapping[str, float] = <factory>, events: tuple[alphalab.research.events.ResearchEvent, ...] = <factory>, metadata: collections.abc.Mapping[str, str] = <factory>) -> None",
      "ResearchStudy": "class alphalab.research.study.ResearchStudy(study_name: 'str', dataset_version: 'str | None', universe: 'tuple[str, ...]', features: 'tuple[FeatureDefinition, ...]', horizons: 'tuple[int, ...]' = (), splits: 'str' = '', parameters: 'Mapping[str, float]' = <factory>, seed: 'int | None' = None, notes: 'str' = '', inputs: 'Mapping[str, str]' = <factory>, implementation_lag: 'int | None' = None) -> None",
      "ResearchValidationError": "class alphalab.research.exceptions.ResearchValidationError",
      "RobustnessReport": "class alphalab.research.sensitivity.RobustnessReport(parameter_count: int, trials: int | None, sensitivity: float | None, neighbour_drop: float | None) -> None",
      "STUDY_KEY_SCHEME": "value builtins.str",
      "SharpeInference": "class alphalab.research.sharpe_inference.SharpeInference(observations: 'int', sharpe: 'float', skewness: 'float', kurtosis: 'float', benchmark_sharpe: 'float', standard_error: 'float', probabilistic_sharpe: 'float') -> None",
      "SignalDiagnostics": "class alphalab.research.signals.SignalDiagnostics(signal_lineage: 'str', dataset_version: 'str | None', horizon: 'int', lag: 'int', label: 'str', observations: 'int', instants: 'int', rank_ic: 'InformationCoefficient', quantiles: 'tuple[QuantileBucket, ...]', buckets_requested: 'int', monotonicity: 'float | None', spread: 'float | None') -> None",
      "SplitInterval": "class alphalab.research.splits.SplitInterval(start: 'float', end: 'float') -> None",
      "SplitReport": "class alphalab.research.splits.SplitReport(scheme: 'str', folds: 'tuple[TimeSplit, ...]' = <factory>, instants: 'int' = 0, label_horizon_seconds: 'float | None' = None, embargo_seconds: 'float' = 0.0) -> None",
      "StabilityReport": "class alphalab.research.overfitting.StabilityReport(dimension: 'str', metric: 'str', by_slice: 'Mapping[str, float]', coefficient_of_variation: 'float | None', weakest: 'str', strongest: 'str', positive_share: 'float') -> None",
      "StressReport": "class alphalab.research.stress.StressReport(base_drawdown: float | None, shock_return: float, shock_drawdown: float | None, gain_multiplier: float, loss_multiplier: float, liquidity_drawdown: float | None) -> None",
      "StudyResult": "class alphalab.research.study.StudyResult(result_id: 'str', study: 'ResearchStudy', metrics: 'Mapping[str, float]' = <factory>, splits: 'SplitReport | None' = None, feature_lineage: 'Mapping[str, str]' = <factory>, findings: 'tuple[str, ...]' = <factory>, warnings: 'tuple[str, ...]' = <factory>, produced_at: 'float' = 0.0) -> None",
      "SweepResult": "class alphalab.research.overfitting.SweepResult(metric: 'str', scores: 'Mapping[str, float]', best: 'str', best_score: 'float', sensitivity: 'float | None', neighbour_drop: 'float | None', higher_is_better: 'bool' = True) -> None",
      "ThresholdRule": "class alphalab.research.regimes.ThresholdRule(signal: 'str', cutoffs: 'tuple[float, ...]', labels: 'tuple[str, ...]') -> None",
      "TimeSplit": "class alphalab.research.splits.TimeSplit(index: 'int', train: 'tuple[float, ...]', validation: 'tuple[float, ...]', train_span: 'SplitInterval', validation_span: 'SplitInterval', test: 'tuple[float, ...]' = (), test_span: 'SplitInterval | None' = None, purged: 'tuple[float, ...]' = (), embargoed: 'tuple[float, ...]' = (), validation_purged: 'tuple[float, ...]' = ()) -> None",
      "TradePayload": "class alphalab.research.protocol.TradePayload(trade_id: str, symbol: str, entry_price: float, exit_price: float, quantity: float, pnl: float, duration_seconds: float) -> None",
      "TrailingQuantileRule": "class alphalab.research.regimes.TrailingQuantileRule(signal: 'str', lookback: 'int', cutoffs: 'tuple[float, ...]', labels: 'tuple[str, ...]') -> None",
      "TransitionFrequency": "class alphalab.research.regimes.TransitionFrequency(previous: 'str', current: 'str', count: 'int', probability: 'float') -> None",
      "WALK_FORWARD_DESIGN_SCHEME": "value builtins.str",
      "WalkForwardDesign": "class alphalab.research.walk_forward_optimization.WalkForwardDesign(space: 'ParameterSpace', refit: 'Refit') -> None",
      "WalkForwardObjective": "alias WalkForwardObjective",
      "WalkForwardOptimization": "class alphalab.research.walk_forward_optimization.WalkForwardOptimization(design: 'WalkForwardDesign', folds: 'tuple[FoldSelection, ...]', result: 'StudyResult') -> None",
      "WalkForwardReport": "class alphalab.research.cross_validation.WalkForwardReport(windows_evaluated: int, window_sharpes: tuple[float, ...], mean_sharpe: float | None, sharpe_variance: float | None, first_to_last_change: float | None) -> None",
      "WindowMode": "enum alphalab.research.walk_forward.WindowMode[ROLLING, EXPANDING]",
      "analyze_regimes": "function alphalab.research.regime.analyze_regimes(payload: alphalab.research.protocol.ResearchPayload) -> alphalab.research.regime.RegimeReport",
      "apply_cost": "function alphalab.research.perturbation.apply_cost(returns: 'Mapping[float, Mapping[str, float]]', cost_per_period: 'float') -> 'dict[float, dict[str, float]]'",
      "apply_purge_and_embargo": "function alphalab.research.purging.apply_purge_and_embargo(candidates: 'Sequence[float]', validation: 'SplitInterval', policy: 'PurgePolicy | None') -> 'PurgeResult'",
      "apply_stress_tests": "function alphalab.research.stress.apply_stress_tests(payload: alphalab.research.protocol.ResearchPayload, shock_return: float, gain_multiplier: float, loss_multiplier: float) -> alphalab.research.stress.StressReport",
      "bias_report": "function alphalab.research.views.bias_report(state: alphalab.research.state.ResearchState) -> alphalab.research.bias.BiasReport | None",
      "block_bootstrap_indices": "function alphalab.research.perturbation.block_bootstrap_indices(count: 'int', block_size: 'int', seed: 'int', blocks: 'int | None' = None) -> 'tuple[int, ...]'",
      "bootstrap_statistics": "function alphalab.research.bootstrap.bootstrap_statistics(payload: alphalab.research.protocol.ResearchPayload, seed: int, iterations: int = 1000) -> alphalab.research.bootstrap.BootstrapReport",
      "build_overfitting_report": "function alphalab.research.overfitting.build_overfitting_report(metric: 'str', in_sample: 'float', out_of_sample: 'float', policy: 'OverfittingPolicy', effective_parameters: 'int', sweep: 'SweepResult | None' = None, period: 'StabilityReport | None' = None, symbol: 'StabilityReport | None' = None) -> 'OverfittingReport'",
      "build_result": "function alphalab.research.study.build_result(study: 'ResearchStudy', metrics: 'Mapping[str, float]', produced_at: 'float', splits: 'SplitReport | None' = None, feature_lineage: 'Mapping[str, str] | None' = None, findings: 'Sequence[str]' = (), warnings: 'Sequence[str]' = ()) -> 'StudyResult'",
      "calculate_cagr": "function alphalab.research.metrics.calculate_cagr(returns: collections.abc.Sequence[float], periods_per_year: int) -> float",
      "calculate_max_drawdown": "function alphalab.common.statistics.compounded_max_drawdown(returns: 'Sequence[float]') -> 'float'",
      "calculate_sharpe": "function alphalab.research.metrics.calculate_sharpe(returns: collections.abc.Sequence[float], periods_per_year: int, risk_free_rate: float) -> float",
      "calculate_volatility": "function alphalab.research.metrics.calculate_volatility(returns: collections.abc.Sequence[float], periods_per_year: int) -> float",
      "canonical_event_study_key": "function alphalab.research.event_study.canonical_event_study_key(definition: 'EventStudyDefinition') -> 'str'",
      "canonical_regime_key": "function alphalab.research.regimes.canonical_regime_key(definition: 'RegimeDefinition') -> 'str'",
      "canonical_result_key": "function alphalab.research.study.canonical_result_key(study: 'ResearchStudy', metrics: 'Mapping[str, float]') -> 'str'",
      "canonical_study_key": "function alphalab.research.study.canonical_study_key(study: 'ResearchStudy') -> 'str'",
      "capacity_report": "function alphalab.research.views.capacity_report(state: alphalab.research.state.ResearchState) -> alphalab.research.capacity.CapacityReport | None",
      "classify_regimes": "function alphalab.research.regimes.classify_regimes(definition: 'RegimeDefinition', signals: 'Mapping[str, Sequence[tuple[float, float]]]', *, input_id: 'str | None', initial: 'RegimeState | None' = None) -> 'RegimeSeries'",
      "conditional_diagnostics": "function alphalab.research.signals.conditional_diagnostics(signal: 'FeaturePanel', returns: 'ForwardReturnPanel', regimes: 'Mapping[float, str]', buckets: 'int' = 5, minimum_assets: 'int' = 5, minimum_instants: 'int' = 2) -> 'dict[str, SignalDiagnostics]'",
      "correct_p_values": "function alphalab.research.multiple_testing.correct_p_values(p_values: 'Mapping[str, float]', correction: 'Correction', alpha: 'float') -> 'MultipleTestingResult'",
      "cross_validation_splits": "function alphalab.research.time_series_cv.cross_validation_splits(timestamps: 'Sequence[float]', folds: 'int', method: 'CVMethod', policy: 'PurgePolicy | None' = None) -> 'SplitReport'",
      "deflated_sharpe_ratio": "function alphalab.research.sharpe_inference.deflated_sharpe_ratio(returns: 'Sequence[float]', trial_sharpes: 'Sequence[float]', *, independent_trials: 'int') -> 'DeflatedSharpe'",
      "delay_signal": "function alphalab.research.perturbation.delay_signal(panel: 'FeaturePanel', periods: 'int') -> 'FeaturePanel'",
      "derive_result_id": "function alphalab.research.study.derive_result_id(study: 'ResearchStudy', metrics: 'Mapping[str, float]') -> 'str'",
      "derive_study_id": "function alphalab.research.study.derive_study_id(study: 'ResearchStudy') -> 'str'",
      "detect_bias": "function alphalab.research.bias.detect_bias(payload: alphalab.research.protocol.ResearchPayload) -> alphalab.research.bias.BiasReport",
      "diagnostic_report": "function alphalab.research.views.diagnostic_report(state: alphalab.research.state.ResearchState) -> alphalab.research.diagnostics.DiagnosticReport | None",
      "drop_observations": "function alphalab.research.perturbation.drop_observations(frame: 'ObservationFrame', fraction: 'float', seed: 'int') -> 'ObservationFrame'",
      "estimate_capacity": "function alphalab.research.capacity.estimate_capacity(payload: alphalab.research.protocol.ResearchPayload) -> alphalab.research.capacity.CapacityReport",
      "event_study": "function alphalab.research.event_study.event_study(events: 'ObservationSet[InformationEvent]', prices: 'ObservationFrame', calendar: 'SessionCalendar', definition: 'EventStudyDefinition') -> 'EventStudyResult'",
      "event_study_metrics": "function alphalab.research.event_study.event_study_metrics(result: 'EventStudyResult') -> 'dict[str, float]'",
      "expected_maximum_sharpe": "function alphalab.research.sharpe_inference.expected_maximum_sharpe(independent_trials: 'int', trial_sharpe_variance: 'float') -> 'float'",
      "generate_diagnostics": "function alphalab.research.diagnostics.generate_diagnostics(payload: alphalab.research.protocol.ResearchPayload, minimum_trades: int, maximum_trade_share: float, worst_period_return: float) -> alphalab.research.diagnostics.DiagnosticReport",
      "initial_regime_state": "function alphalab.research.regimes.initial_regime_state(definition: 'RegimeDefinition') -> 'RegimeState'",
      "label_ends_from_horizon": "function alphalab.research.purging.label_ends_from_horizon(timestamps: 'Sequence[float]', horizon_periods: 'int') -> 'dict[float, float]'",
      "monte_carlo_orders": "function alphalab.research.perturbation.monte_carlo_orders(count: 'int', paths: 'int', seed: 'int') -> 'tuple[tuple[int, ...], ...]'",
      "monte_carlo_simulation": "function alphalab.research.montecarlo.monte_carlo_simulation(payload: alphalab.research.protocol.ResearchPayload, seed: int, ruin_drawdown: float, simulations: int = 1000) -> alphalab.research.montecarlo.MonteCarloReport",
      "parameter_robustness": "function alphalab.research.sensitivity.parameter_robustness(payload: alphalab.research.protocol.ResearchPayload) -> alphalab.research.sensitivity.RobustnessReport",
      "parameter_sweep": "function alphalab.research.overfitting.parameter_sweep(metric: 'str', configurations: 'Sequence[str]', evaluate: 'Callable[[str], float]', *, higher_is_better: 'bool' = True) -> 'SweepResult'",
      "per_period_sharpe": "function alphalab.research.sharpe_inference.per_period_sharpe(returns: 'Sequence[float]') -> 'float'",
      "period_stability": "function alphalab.research.overfitting.period_stability(metric: 'str', by_period: 'Mapping[str, float]') -> 'StabilityReport'",
      "perturb_observations": "function alphalab.research.perturbation.perturb_observations(frame: 'ObservationFrame', relative_sigma: 'float', seed: 'int') -> 'ObservationFrame'",
      "perturb_signal": "function alphalab.research.perturbation.perturb_signal(panel: 'FeaturePanel', absolute_sigma: 'float', seed: 'int') -> 'FeaturePanel'",
      "probabilistic_sharpe_ratio": "function alphalab.research.sharpe_inference.probabilistic_sharpe_ratio(returns: 'Sequence[float]', benchmark_sharpe: 'float') -> 'SharpeInference'",
      "regime_profile": "function alphalab.research.regimes.regime_profile(series: 'RegimeSeries', returns: 'Mapping[float, float] | None') -> 'RegimeProfile'",
      "regime_series_from_features": "function alphalab.research.regimes.regime_series_from_features(definition: 'RegimeDefinition', features: 'Mapping[str, FeatureSeries]', *, initial: 'RegimeState | None' = None) -> 'RegimeSeries'",
      "require_chronological": "function alphalab.research.splits.require_chronological(timestamps: 'Sequence[float]') -> 'tuple[float, ...]'",
      "research_metrics": "function alphalab.research.research.research_metrics(payload: alphalab.research.protocol.ResearchPayload, bias: alphalab.research.bias.BiasReport, walk_forward: alphalab.research.cross_validation.WalkForwardReport, monte_carlo: alphalab.research.montecarlo.MonteCarloReport, bootstrap: alphalab.research.bootstrap.BootstrapReport, robustness: alphalab.research.sensitivity.RobustnessReport, regime: alphalab.research.regime.RegimeReport, capacity: alphalab.research.capacity.CapacityReport, stress: alphalab.research.stress.StressReport) -> collections.abc.Mapping[str, float]",
      "research_metrics_of": "function alphalab.research.views.research_metrics_of(state: alphalab.research.state.ResearchState) -> collections.abc.Mapping[str, float]",
      "sample_by": "function alphalab.research.perturbation.sample_by(values: 'Sequence[float]', positions: 'Sequence[int]') -> 'tuple[float, ...]'",
      "sample_degradation": "function alphalab.research.overfitting.sample_degradation(in_sample: 'float', out_of_sample: 'float') -> 'float | None'",
      "shift_parameter": "function alphalab.research.perturbation.shift_parameter(window: 'int', relative: 'float') -> 'int'",
      "signal_diagnostics": "function alphalab.research.signals.signal_diagnostics(signal: 'FeaturePanel', returns: 'ForwardReturnPanel', buckets: 'int' = 5, minimum_assets: 'int' = 5, tie_break: 'TieBreak' = <TieBreak.LOW: 1>, label: 'str' = '', instants: 'Sequence[float] | None' = None) -> 'SignalDiagnostics'",
      "signal_horizons": "function alphalab.research.signals.signal_horizons(signal: 'FeaturePanel', prices: 'ObservationFrame', horizons: 'Sequence[int]', buckets: 'int' = 5, minimum_assets: 'int' = 5, *, lag: 'int', delistings: 'Sequence[DelistingReturn]') -> 'dict[int, SignalDiagnostics]'",
      "stress_report": "function alphalab.research.views.stress_report(state: alphalab.research.state.ResearchState) -> alphalab.research.stress.StressReport | None",
      "symbol_stability": "function alphalab.research.overfitting.symbol_stability(metric: 'str', by_symbol: 'Mapping[str, float]') -> 'StabilityReport'",
      "validate_payload": "function alphalab.research.validation.validate_payload(payload: alphalab.research.protocol.ResearchPayload) -> None",
      "walk_forward_analysis": "function alphalab.research.cross_validation.walk_forward_analysis(payload: alphalab.research.protocol.ResearchPayload, num_windows: int) -> alphalab.research.cross_validation.WalkForwardReport",
      "walk_forward_optimize": "function alphalab.research.walk_forward_optimization.walk_forward_optimize(study: 'ResearchStudy', design: 'WalkForwardDesign', objective: 'WalkForwardObjective', splits: 'SplitReport', *, produced_at: 'float') -> 'WalkForwardOptimization'",
      "walk_forward_splits": "function alphalab.research.walk_forward.walk_forward_splits(timestamps: 'Sequence[float]', train_size: 'int', validation_size: 'int', test_size: 'int', mode: 'WindowMode', step: 'int | None' = None, policy: 'PurgePolicy | None' = None) -> 'SplitReport'",
      "warnings": "function alphalab.research.views.warnings(state: alphalab.research.state.ResearchState) -> collections.abc.Sequence[str]"
    },
    "alphalab.research_assistant": {
      "AssistantReport": "class alphalab.research_assistant.report.AssistantReport(title: str, template: str, objective: str, higher_is_better: bool, candidate_count: int, best_candidate_id: str, best_score: float, ranked_rows: tuple[tuple[str, float], ...] = <factory>, generated_at: float = 0.0) -> None",
      "CandidateEvaluation": "class alphalab.research_assistant.evaluation.CandidateEvaluation(candidate: alphalab.research_assistant.generation.StrategyCandidate, metrics: collections.abc.Mapping[str, float], score: float) -> None",
      "Evaluator": "alias collections.abc.Callable[[alphalab.research_assistant.generation.StrategyCandidate], collections.abc.Mapping[str, float]]",
      "ParameterAxes": "alias ParameterAxes",
      "ParameterSpace": "class alphalab.research.walk_forward_optimization.ParameterSpace(candidates: 'tuple[Mapping[str, ParamValue], ...]') -> None",
      "ResearchAssistantError": "class alphalab.research_assistant.exceptions.ResearchAssistantError",
      "ResearchAssistantInputError": "class alphalab.research_assistant.exceptions.ResearchAssistantInputError",
      "ResearchWorkflowResult": "class alphalab.research_assistant.workflow.ResearchWorkflowResult(template: str, objective: str, candidates: tuple[alphalab.research_assistant.generation.StrategyCandidate, ...], evaluations: tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...], best: alphalab.research_assistant.evaluation.CandidateEvaluation, report: alphalab.research_assistant.report.AssistantReport, sweep: alphalab.research.overfitting.SweepResult, tracker: alphalab.experiment_tracking.tracker.ExperimentTracker | None = None) -> None",
      "StrategyCandidate": "class alphalab.research_assistant.generation.StrategyCandidate(candidate_id: str, template: str, parameters: collections.abc.Mapping[str, ParamValue] = <factory>) -> None",
      "best_evaluation": "function alphalab.research_assistant.evaluation.best_evaluation(evaluations: tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...], higher_is_better: bool = True) -> alphalab.research_assistant.evaluation.CandidateEvaluation",
      "build_report": "function alphalab.research_assistant.report.build_report(template: str, objective: str, evaluations: tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...], timestamp: float, higher_is_better: bool = True, title: str | None = None) -> alphalab.research_assistant.report.AssistantReport",
      "candidate_count": "function alphalab.research_assistant.generation.candidate_count(space: alphalab.research.walk_forward_optimization.ParameterSpace | ParameterAxes) -> int",
      "evaluate_candidates": "function alphalab.research_assistant.evaluation.evaluate_candidates(candidates: tuple[alphalab.research_assistant.generation.StrategyCandidate, ...], evaluator: collections.abc.Callable[[alphalab.research_assistant.generation.StrategyCandidate], collections.abc.Mapping[str, float]], objective: str, higher_is_better: bool = True) -> tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...]",
      "generate_candidates": "function alphalab.research_assistant.generation.generate_candidates(template: str, space: alphalab.research.walk_forward_optimization.ParameterSpace | ParameterAxes, limit: int | None = None) -> tuple[alphalab.research_assistant.generation.StrategyCandidate, ...]",
      "parameter_space": "function alphalab.research_assistant.generation.parameter_space(space: alphalab.research.walk_forward_optimization.ParameterSpace | ParameterAxes) -> alphalab.research.walk_forward_optimization.ParameterSpace",
      "rank_evaluations": "function alphalab.research_assistant.evaluation.rank_evaluations(evaluations: tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...], higher_is_better: bool = True) -> tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...]",
      "render_markdown": "function alphalab.research_assistant.report.render_markdown(report: alphalab.research_assistant.report.AssistantReport) -> str",
      "run_research_workflow": "function alphalab.research_assistant.workflow.run_research_workflow(template: str, space: alphalab.research.walk_forward_optimization.ParameterSpace | ParameterAxes, evaluator: collections.abc.Callable[[alphalab.research_assistant.generation.StrategyCandidate], collections.abc.Mapping[str, float]], objective: str, timestamp: float, higher_is_better: bool = True, limit: int | None = None, tracker: alphalab.experiment_tracking.tracker.ExperimentTracker | None = None) -> alphalab.research_assistant.workflow.ResearchWorkflowResult",
      "to_strategy_definition": "function alphalab.research_assistant.definition.to_strategy_definition(candidate: alphalab.research_assistant.generation.StrategyCandidate, name: str, version: str, author: str, description: str, metadata: collections.abc.Mapping[str, str] | None = None) -> alphalab.strategy.definition.StrategyDefinition",
      "top_k": "function alphalab.research_assistant.evaluation.top_k(evaluations: tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...], k: int, higher_is_better: bool = True) -> tuple[alphalab.research_assistant.evaluation.CandidateEvaluation, ...]"
    },
    "alphalab.risk": {
      "BucketExposure": "class alphalab.risk.projection.BucketExposure(dimension: 'str', label: 'str | None', committed_gross: 'Decimal', projected_gross: 'Decimal') -> None",
      "BuyingPowerUpdated": "class alphalab.risk.events.BuyingPowerUpdated(event_id: str, timestamp: float, buying_power: decimal.Decimal) -> None",
      "ClassificationLimit": "class alphalab.risk.limits.ClassificationLimit(dimension: str, max_gross: decimal.Decimal | None = None, max_share: decimal.Decimal | None = None, label: str | None = None, refuse_unclassified: bool = False) -> None",
      "DailyLossLimit": "class alphalab.risk.limits.DailyLossLimit(max_daily_loss: decimal.Decimal, zone: str, day_start: datetime.time = datetime.time(0, 0)) -> None",
      "DrawdownLimit": "class alphalab.risk.limits.DrawdownLimit(max_drawdown_pct: decimal.Decimal) -> None",
      "DrawdownTriggered": "class alphalab.risk.events.DrawdownTriggered(event_id: str, timestamp: float, current_drawdown: decimal.Decimal, max_drawdown: decimal.Decimal) -> None",
      "ExposureLimit": "class alphalab.risk.limits.ExposureLimit(max_gross_exposure: decimal.Decimal, max_net_exposure: decimal.Decimal) -> None",
      "ExposureStatus": "class alphalab.risk.exposure.ExposureStatus(gross_exposure: decimal.Decimal = Decimal('0.00'), net_exposure: decimal.Decimal = Decimal('0.00'), long_exposure: decimal.Decimal = Decimal('0.00'), short_exposure: decimal.Decimal = Decimal('0.00'), asset_exposure: collections.abc.Mapping[str, decimal.Decimal] = <factory>, sector_exposure: collections.abc.Mapping[str, decimal.Decimal] = <factory>) -> None",
      "ExposureUpdated": "class alphalab.risk.events.ExposureUpdated(event_id: str, timestamp: float, gross_exposure: decimal.Decimal, net_exposure: decimal.Decimal) -> None",
      "LeverageLimit": "class alphalab.risk.limits.LeverageLimit(max_leverage: decimal.Decimal) -> None",
      "MarginLimit": "class alphalab.risk.limits.MarginLimit(max_margin_utilization: decimal.Decimal) -> None",
      "MarginStatus": "class alphalab.risk.margin.MarginStatus(initial_margin: decimal.Decimal = Decimal('0.00'), maintenance_margin: decimal.Decimal = Decimal('0.00'), available_margin: decimal.Decimal = Decimal('0.00'), margin_used: decimal.Decimal = Decimal('0.00')) -> None",
      "MarginUpdated": "class alphalab.risk.events.MarginUpdated(event_id: str, timestamp: float, margin_used: decimal.Decimal, available_margin: decimal.Decimal) -> None",
      "NO_WORKING_ORDERS": "value builtins.mappingproxy",
      "OrderRequest": "class alphalab.core.order_request.OrderRequest(order_id: str, strategy_id: str, asset_id: str, side: alphalab.core.enums.Side, quantity: decimal.Decimal, price: decimal.Decimal, timestamp: float = 0.0, contributions: tuple[alphalab.core.contribution.StrategyContribution, ...] = <factory>, terms: alphalab.common.order_terms.OrderTerms = OrderTerms(order_type=<OrderType.MARKET: 'market'>, limit_price=None, stop_price=None, time_in_force=<TimeInForce.DAY: 'day'>, expire_at=None)) -> None",
      "OrderSizeLimit": "class alphalab.risk.limits.OrderSizeLimit(max_quantity: decimal.Decimal, max_notional: decimal.Decimal) -> None",
      "PositionLimit": "class alphalab.risk.limits.PositionLimit(max_quantity: decimal.Decimal, max_notional: decimal.Decimal) -> None",
      "RiskApproved": "class alphalab.risk.events.RiskApproved(event_id: str, timestamp: float, decision_id: str, order_id: str) -> None",
      "RiskCheckStarted": "class alphalab.risk.events.RiskCheckStarted(event_id: str, timestamp: float, request: alphalab.core.order_request.OrderRequest) -> None",
      "RiskConfigurationError": "class alphalab.risk.exceptions.RiskConfigurationError",
      "RiskDecision": "class alphalab.risk.decision.RiskDecision(decision_id: str, timestamp: float, order_id: str, approved: bool, reason: str, violations: tuple[alphalab.risk.models.RiskViolation, ...] = <factory>, required_margin: decimal.Decimal = Decimal('0.00'), remaining_buying_power: decimal.Decimal = Decimal('0.00'), exposure: alphalab.risk.exposure.ExposureStatus = <factory>, breaches: tuple[alphalab.risk.models.RiskViolation, ...] = <factory>) -> None",
      "RiskEngine": "class alphalab.risk.engine.RiskEngine()",
      "RiskError": "class alphalab.risk.exceptions.RiskError",
      "RiskEvent": "class alphalab.risk.events.RiskEvent(event_id: str, timestamp: float) -> None",
      "RiskLimits": "class alphalab.risk.limits.RiskLimits(order_size: alphalab.risk.limits.OrderSizeLimit, position: alphalab.risk.limits.PositionLimit, exposure: alphalab.risk.limits.ExposureLimit, leverage: alphalab.risk.limits.LeverageLimit, margin: alphalab.risk.limits.MarginLimit, daily_loss: alphalab.risk.limits.DailyLossLimit | None, drawdown: alphalab.risk.limits.DrawdownLimit, classification: tuple[alphalab.risk.limits.ClassificationLimit, ...] = ()) -> None",
      "RiskProjection": "class alphalab.risk.projection.RiskProjection(asset_id: 'str', order_quantity: 'Decimal', price: 'Decimal', committed_position: 'Decimal', projected_position: 'Decimal', committed_gross: 'Decimal', projected_gross: 'Decimal', committed_net: 'Decimal', projected_net: 'Decimal', increasing_notional: 'Decimal', available_buying_power: 'Decimal', nav: 'Decimal') -> None",
      "RiskRejected": "class alphalab.risk.events.RiskRejected(event_id: str, timestamp: float, decision_id: str, order_id: str, reason: str) -> None",
      "RiskSeverity": "enum alphalab.risk.models.RiskSeverity[HIGH, CRITICAL]",
      "RiskState": "class alphalab.risk.state.RiskState(active_limits: alphalab.risk.limits.RiskLimits, margin: alphalab.risk.margin.MarginStatus = <factory>, exposure: alphalab.risk.exposure.ExposureStatus = <factory>, cash: decimal.Decimal = Decimal('0.00'), buying_power: decimal.Decimal = Decimal('0.00'), peak_nav: decimal.Decimal = Decimal('0.00'), current_nav: decimal.Decimal = Decimal('0.00'), daily_loss: decimal.Decimal = Decimal('0.00'), history: alphalab.common.append_log.AppendOnlyLog[alphalab.risk.decision.RiskDecision] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.risk.events.RiskEvent] = <factory>, trading_day: str | None = None, day_start_nav: decimal.Decimal | None = None) -> None",
      "RiskValidationError": "class alphalab.risk.exceptions.RiskValidationError",
      "RiskViolation": "class alphalab.risk.models.RiskViolation(rule: str, description: str, severity: alphalab.risk.models.RiskSeverity, current_value: decimal.Decimal, allowed_value: decimal.Decimal) -> None",
      "WorkingExposure": "class alphalab.risk.projection.WorkingExposure(quantity: 'Decimal', price: 'Decimal', position: 'Decimal') -> None",
      "active_limits": "function alphalab.risk.views.active_limits(state: alphalab.risk.state.RiskState) -> alphalab.risk.limits.RiskLimits",
      "check_buying_power": "function alphalab.risk.checks.check_buying_power(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_classification": "function alphalab.risk.checks.check_classification(state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection, buckets: tuple[alphalab.risk.projection.BucketExposure, ...]) -> alphalab.risk.models.RiskViolation | None",
      "check_daily_loss": "function alphalab.risk.checks.check_daily_loss(state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_drawdown": "function alphalab.risk.checks.check_drawdown(state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_exposure": "function alphalab.risk.checks.check_exposure(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_leverage": "function alphalab.risk.checks.check_leverage(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_margin": "function alphalab.risk.checks.check_margin(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_net_exposure": "function alphalab.risk.checks.check_net_exposure(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_order_size": "function alphalab.risk.checks.check_order_size(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "check_position_limit": "function alphalab.risk.checks.check_position_limit(request: alphalab.core.order_request.OrderRequest, state: alphalab.risk.state.RiskState, projection: alphalab.risk.projection.RiskProjection) -> alphalab.risk.models.RiskViolation | None",
      "current_exposure": "function alphalab.risk.views.current_exposure(state: alphalab.risk.state.RiskState) -> alphalab.risk.exposure.ExposureStatus",
      "daily_loss_breach": "function alphalab.risk.checks.daily_loss_breach(state: alphalab.risk.state.RiskState) -> alphalab.risk.models.RiskViolation | None",
      "drawdown_breach": "function alphalab.risk.checks.drawdown_breach(state: alphalab.risk.state.RiskState) -> alphalab.risk.models.RiskViolation | None",
      "latest_decision": "function alphalab.risk.views.latest_decision(state: alphalab.risk.state.RiskState) -> alphalab.risk.decision.RiskDecision | None",
      "margin_status": "function alphalab.risk.views.margin_status(state: alphalab.risk.state.RiskState) -> alphalab.risk.margin.MarginStatus",
      "project": "function alphalab.risk.projection.project(state: 'RiskState', request: 'OrderRequest', *, position: 'Decimal', price: 'Decimal', working: 'Mapping[str, WorkingExposure]' = mappingproxy({})) -> 'RiskProjection'",
      "risk_history": "function alphalab.risk.views.risk_history(state: alphalab.risk.state.RiskState) -> collections.abc.Sequence[alphalab.risk.decision.RiskDecision]",
      "validate_order_request": "function alphalab.risk.validation.validate_order_request(request: alphalab.core.order_request.OrderRequest) -> None",
      "violations": "function alphalab.risk.views.violations(state: alphalab.risk.state.RiskState) -> collections.abc.Sequence[alphalab.risk.models.RiskViolation]"
    },
    "alphalab.runtime": {
      "AlphaLabRuntimeError": "class alphalab.runtime.exceptions.AlphaLabRuntimeError",
      "CHECKPOINT_SCHEMA": "value builtins.int",
      "CheckpointMark": "class alphalab.runtime.checkpoint.CheckpointMark(sequence: 'int', digest: 'str', ends: 'Mapping[str, int]', entries: 'Mapping[str, tuple[tuple[Any, Any], ...]]' = <factory>) -> None",
      "ChildOrderBindings": "class alphalab.runtime.broker_routing.ChildOrderBindings(to_parent: 'PersistentMap[str, str]' = <factory>, by_parent: 'PersistentMap[str, tuple[str, ...]]' = <factory>) -> None",
      "ChildRoutingResult": "class alphalab.runtime.broker_routing.ChildRoutingResult(broker_state: 'BrokerState', children: 'ChildOrderBindings', order: 'BrokerOrder | None', decision: 'RoutingDecision', events: 'tuple[BrokerEvent, ...]' = ()) -> None",
      "ExecutionAssumptions": "class alphalab.runtime.assumptions.ExecutionAssumptions(routing: 'ExecutionRouting', fill_timing: 'FillTiming', fill_policy: 'str', costs: 'str', latency: 'str', frictionless: 'bool', unlimited_liquidity: 'bool') -> None",
      "ExecutionMode": "enum alphalab.runtime.run.ExecutionMode[BACKTEST, REPLAY, PAPER, LIVE]",
      "ExecutionPipeline": "class alphalab.runtime.execution_pipeline.ExecutionPipeline()",
      "ExecutionPipelineConfig": "class alphalab.runtime.execution_pipeline.ExecutionPipelineConfig(account: 'Account', starting_cash: 'Decimal', budget: 'CapitalBudget', allocation_constraints: 'AllocationConstraints', risk_limits: 'RiskLimits', sizing_model: 'SizingModel' = <factory>, simulator: 'ExecutionSimulator' = <factory>, venue: 'str' = 'SIM', currency: 'str' = '', also_settles: 'frozenset[str]' = frozenset(), routing: 'ExecutionRouting' = <ExecutionRouting.SIMULATED: 1>, instruments: 'InstrumentRegistry | None' = None, fill_timing: 'FillTiming' = <FillTiming.SAME_EVENT: 'same_event'>, calendars: 'VenueCalendars' = <factory>, retention: 'RetentionPolicy' = <factory>) -> None",
      "ExecutionPipelineResult": "class alphalab.runtime.execution_pipeline.ExecutionPipelineResult(state: 'ExecutionPipelineState', market_event: 'MarketEvent', intents: 'tuple[Intent, ...]', order_requests: 'tuple[OrderRequest, ...]', risk_decisions: 'tuple[RiskDecision, ...]', oms_orders: 'tuple[OMSOrder, ...]', execution_reports: 'tuple[ExecutionReport, ...]', fills: 'tuple[CoreFill, ...]', trades: 'tuple[CoreTrade, ...]', unpriced_requests: 'tuple[OrderRequest, ...]' = <factory>, valuation: 'PortfolioValuationSnapshot | None' = None, settlement_refusals: 'tuple[SettlementRefusal, ...]' = <factory>) -> None",
      "ExecutionPipelineState": "class alphalab.runtime.execution_pipeline.ExecutionPipelineState(config: 'ExecutionPipelineConfig', market: 'MarketState', strategy: 'StrategyRuntimeState', allocation: 'AllocationState', risk: 'RiskState', oms: 'OMSState', execution: 'ExecutionState', portfolio: 'PortfolioState', analytics: 'AnalyticsState', market_prices: 'Mapping[str, Decimal]' = <factory>, fills: 'AppendOnlyLog[CoreFill]' = <factory>, trades: 'AppendOnlyLog[CoreTrade]' = <factory>, trade_records: 'AppendOnlyLog[TradeRecord]' = <factory>, portfolio_snapshots: 'AppendOnlyLog[PortfolioSnapshot]' = <factory>, unpriced_assets: 'PersistentMap[str, UnpricedAsset]' = <factory>, id_position: 'IdStreamPosition' = <factory>) -> None",
      "ExecutionRouting": "enum alphalab.runtime.execution_pipeline.ExecutionRouting[SIMULATED, EXTERNAL]",
      "HistoryNotRetainedError": "class alphalab.runtime.exceptions.HistoryNotRetainedError",
      "LiveRunState": "class alphalab.runtime.live.LiveRunState(run: 'RunState', broker: 'BrokerState', routing: 'RoutingConfig', mapping: 'ExternalOrderMap' = <factory>, reconciliation: 'ReconciliationLog' = <factory>, routed: 'AppendOnlyLog[RoutedOrder]' = <factory>, settled: 'AppendOnlyLog[SettledExecution]' = <factory>, children: 'ChildOrderBindings' = <factory>, requests: 'RequestLedger' = <factory>, held: 'frozenset[str]' = frozenset()) -> None",
      "LiveSession": "class alphalab.runtime.live.LiveSession()",
      "LiveStep": "class alphalab.runtime.live.LiveStep(settled: 'tuple[SettledExecution, ...]' = (), routed: 'tuple[RoutedOrder, ...]' = (), result: 'ExecutionPipelineResult | None' = None, events: 'tuple[BrokerEvent, ...]' = ()) -> None",
      "RetentionPolicy": "class alphalab.runtime.retention.RetentionPolicy(market_history: 'int | None' = None, steps: 'int | None' = None, audit_events: 'int | None' = None, results: 'int | None' = None) -> None",
      "RoutedOrder": "class alphalab.runtime.live.RoutedOrder(oms_order_id: 'str', broker_order_id: 'str | None', decision: 'RoutingDecision') -> None",
      "RoutingConfig": "class alphalab.runtime.broker_routing.RoutingConfig(venue: 'str', currency: 'str', order_type: 'OrderType' = <OrderType.MARKET: 'market'>) -> None",
      "RoutingDecision": "class alphalab.runtime.broker_routing.RoutingDecision(routed: 'bool', refusal: 'RoutingRefusal | None' = None, reason: 'str' = '') -> None",
      "RoutingRefusal": "enum alphalab.runtime.broker_routing.RoutingRefusal[DISCONNECTED, DUPLICATE_SUBMISSION, CAPABILITY_MISMATCH, INVALID_CHILD, PARENT_ROUTED_DIRECTLY]",
      "RoutingResult": "class alphalab.runtime.broker_routing.RoutingResult(broker_state: 'BrokerState', mapping: 'ExternalOrderMap', order: 'BrokerOrder | None', decision: 'RoutingDecision', events: 'tuple[BrokerEvent, ...]' = ()) -> None",
      "RunConfig": "class alphalab.runtime.run.RunConfig(pipeline: 'ExecutionPipelineConfig', mode: 'ExecutionMode', fill_policy: 'FillPolicy' = <factory>, seed: 'int | None' = None, start_timestamp: 'float' = 0.0, ordering: 'OrderingGuarantee' = <OrderingGuarantee.CHRONOLOGICAL: 1>, max_market_data_age_seconds: 'float | None' = None, years_elapsed: 'float | None' = None, risk_free_rate: 'float' = 0.0, compile_analytics: 'bool' = True, periods_per_year: 'float | None' = None, halt_on_strategy_failure: 'bool' = False) -> None",
      "RunEngine": "class alphalab.runtime.run.RunEngine()",
      "RunState": "class alphalab.runtime.run.RunState(config: 'RunConfig', pipeline: 'ExecutionPipelineState', processed: 'int' = 0, current_timestamp: 'float' = 0.0, last_record_timestamp: 'float | None' = None, source_id: 'str | None' = None, steps: 'AppendOnlyLog[RunStep]' = <factory>, skipped: 'AppendOnlyLog[SkippedRecord]' = <factory>, last_slice_at: 'float | None' = None, observations_delivered: 'int' = 0, last_observation: 'tuple[float, str] | None' = None) -> None",
      "RunStep": "class alphalab.runtime.run.RunStep(index: 'int', event_id: 'str', timestamp: 'float', orders: 'tuple[OMSOrder, ...]', reports: 'tuple[ExecutionReport, ...]', fills: 'tuple[CoreFill, ...]', equity: 'Decimal') -> None",
      "RuntimeValidationError": "class alphalab.runtime.exceptions.RuntimeValidationError",
      "SettledExecution": "class alphalab.runtime.live.SettledExecution(execution: 'BrokerExecution', decision: 'ExecutionDecision', fills: 'tuple[CoreFill, ...]' = ()) -> None",
      "SettlementRefusal": "class alphalab.runtime.execution_pipeline.SettlementRefusal(asset_id: 'str', instrument_currency: 'str', settlement_currency: 'str', detail: 'str', timestamp: 'float') -> None",
      "SkippedRecord": "class alphalab.runtime.run.SkippedRecord(record: 'MarketRecord', reason: 'str') -> None",
      "StrategyFailedError": "class alphalab.runtime.run.StrategyFailedError(message: 'str', state: 'RunState', failures: 'tuple[StrategyFailure, ...]') -> 'None'",
      "StrategyFailure": "class alphalab.runtime.run.StrategyFailure(strategy_id: 'str', timestamp: 'float', error: 'str') -> None",
      "TradingSession": "class alphalab.runtime.session.TradingSession()",
      "UnpricedAsset": "class alphalab.runtime.execution_pipeline.UnpricedAsset(asset_id: 'str', reason: 'UnpricedReason', detail: 'str', first_timestamp: 'float', last_timestamp: 'float', occurrences: 'int') -> None",
      "UnpricedReason": "enum alphalab.runtime.execution_pipeline.UnpricedReason[NO_PRICE_OBSERVED, NOT_REGISTERED, REGISTERED_BUT_UNPRICED]",
      "VenueCalendars": "class alphalab.runtime.calendars.VenueCalendars(by_exchange: 'Mapping[str, MarketCalendar]' = <factory>, default: 'MarketCalendar | None' = None) -> None",
      "apply_broker_execution": "function alphalab.runtime.broker_routing.apply_broker_execution(state: 'ExecutionPipelineState', oms_order: 'OMSOrder', execution: 'BrokerExecution', config: 'RoutingConfig', rates: 'FxRates' = FxRates(rates={}, max_age_seconds=None, currency_units=CurrencyUnits({}))) -> 'tuple[ExecutionPipelineState, tuple[CoreFill, ...], tuple[CoreTrade, ...]]'",
      "checkpoint": "function alphalab.runtime.checkpoint.checkpoint(state: 'RunState', previous: 'CheckpointMark | None' = None) -> 'tuple[str, CheckpointMark]'",
      "child_broker_order_id": "function alphalab.runtime.broker_routing.child_broker_order_id(parent: 'OMSOrder', sequence: 'int') -> 'str'",
      "execution_assumptions": "function alphalab.runtime.assumptions.execution_assumptions(pipeline: 'ExecutionPipelineConfig', fill_policy: 'FillPolicy') -> 'ExecutionAssumptions'",
      "execution_report_from_broker": "function alphalab.runtime.broker_routing.execution_report_from_broker(execution: 'BrokerExecution', oms_order: 'OMSOrder', config: 'RoutingConfig') -> 'ExecutionReport'",
      "live_health": "function alphalab.runtime.live.live_health(state: 'LiveRunState') -> 'tuple[str, ...]'",
      "read_checkpoints": "function alphalab.runtime.checkpoint.read_checkpoints(payloads: 'Sequence[str]') -> 'RunSnapshot'",
      "restore_checkpoints": "function alphalab.runtime.checkpoint.restore_checkpoints(payloads: 'Sequence[str]', objects: 'RunObjects') -> 'RunState'",
      "route_child_order": "function alphalab.runtime.broker_routing.route_child_order(broker_state: 'BrokerState', broker: 'BrokerProtocol', parent: 'OMSOrder', child: 'ChildOrder', timestamp: 'float', *, mapping: 'ExternalOrderMap', children: 'ChildOrderBindings', config: 'RoutingConfig', capability: 'CompatibilityReport | None') -> 'ChildRoutingResult'",
      "route_order": "function alphalab.runtime.broker_routing.route_order(broker_state: 'BrokerState', broker: 'BrokerProtocol', oms_order: 'OMSOrder', timestamp: 'float', mapping: 'ExternalOrderMap | None' = None, *, config: 'RoutingConfig', capability: 'CompatibilityReport | None' = None) -> 'RoutingResult'",
      "venue_order_type": "function alphalab.runtime.broker_routing.venue_order_type(oms_order: 'OMSOrder', routing: 'RoutingConfig') -> 'OrderType'",
      "wants_slices": "function alphalab.runtime.execution_pipeline.wants_slices(strategies: 'StrategyRuntimeState') -> 'bool'"
    },
    "alphalab.runtime.live_snapshot": {
      "IssuedRequestRecord": "class alphalab.runtime.live_snapshot.IssuedRequestRecord(kind: \"Literal['cancel', 'modify']\", request: 'CancelRequest | ModifyRequest') -> None",
      "LIVE_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "LIVE_SNAPSHOT_SCHEMA": "value builtins.int",
      "LiveRunSnapshot": "class alphalab.runtime.live_snapshot.LiveRunSnapshot(run: 'RunSnapshot', broker: 'BrokerSnapshot', venue: 'str', currency: 'str', order_type: 'OrderType', requests: 'tuple[IssuedRequestRecord, ...]' = (), held: 'tuple[str, ...]' = (), schema_version: 'int' = 2) -> None",
      "capture": "function alphalab.runtime.live_snapshot.capture(state: 'LiveRunState') -> 'LiveRunSnapshot'",
      "from_primitives": "function alphalab.runtime.live_snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'LiveRunSnapshot'",
      "restore": "function alphalab.runtime.live_snapshot.restore(snapshot: 'LiveRunSnapshot', objects: 'RunObjects') -> 'LiveRunState'"
    },
    "alphalab.runtime.run_snapshot": {
      "RUN_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "RUN_SNAPSHOT_SCHEMA": "value builtins.int",
      "RunObjects": "class alphalab.runtime.run_snapshot.RunObjects(pipeline: 'RuntimeObjects', fill_policy: 'FillPolicy') -> None",
      "RunSnapshot": "class alphalab.runtime.run_snapshot.RunSnapshot(pipeline: 'PipelineSnapshot', mode: 'ExecutionMode', seed: 'int | None', start_timestamp: 'float', ordering: 'OrderingGuarantee', max_market_data_age_seconds: 'float | None', years_elapsed: 'float | None', risk_free_rate: 'float', compile_analytics: 'bool', fill_policy_type: 'str', processed: 'int', current_timestamp: 'float', last_record_timestamp: 'float | None', source_id: 'str | None', steps: 'tuple[RunStep, ...]', skipped: 'tuple[SkippedRecordRecord, ...]', periods_per_year: 'float | None' = None, halt_on_strategy_failure: 'bool' = False, last_slice_at: 'float | None' = None, observations_delivered: 'int' = 0, last_observation: 'tuple[float, str] | None' = None, dropped: 'Mapping[str, int]' = <factory>, fill_policy_description: 'str | None' = None, schema_version: 'int' = 5) -> None",
      "SkippedRecordRecord": "class alphalab.runtime.run_snapshot.SkippedRecordRecord(payload_type: 'str', record: 'MarketRecord', reason: 'str') -> None",
      "capture": "function alphalab.runtime.run_snapshot.capture(state: 'RunState') -> 'RunSnapshot'",
      "from_primitives": "function alphalab.runtime.run_snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'RunSnapshot'",
      "restore": "function alphalab.runtime.run_snapshot.restore(snapshot: 'RunSnapshot', objects: 'RunObjects') -> 'RunState'"
    },
    "alphalab.runtime.snapshot": {
      "AnalyticsEventRecord": "class alphalab.runtime.snapshot.AnalyticsEventRecord(event_type: 'str', event: 'AnalyticsEvent') -> None",
      "ExecutionEventRecord": "class alphalab.runtime.snapshot.ExecutionEventRecord(event_type: 'str', event: 'ExecutionEvent') -> None",
      "MarketEventRecord": "class alphalab.runtime.snapshot.MarketEventRecord(event_type: 'str', event: 'MarketEvent') -> None",
      "NOT_ASKED": "value alphalab.runtime.snapshot._NotAsked",
      "PIPELINE_SCHEMA_HISTORY": "value alphalab.persistence.upgrade.SchemaHistory",
      "PIPELINE_SNAPSHOT_SCHEMA": "value builtins.int",
      "PipelineSnapshot": "class alphalab.runtime.snapshot.PipelineSnapshot(config: 'ConfigRecord', market: 'MarketRecord', strategy: 'tuple[StrategyRecord, ...]', strategy_events: 'tuple[StrategyEventRecord, ...]', allocation: 'AllocationSnapshot', risk: 'RiskRecord', oms: 'OMSSnapshot', execution: 'ExecutionRecord', portfolio: 'PortfolioSnapshot', analytics: 'AnalyticsRecord', market_prices: 'Mapping[str, Decimal]', fills: 'tuple[CoreFill, ...]', trades: 'tuple[CoreTrade, ...]', trade_records: 'tuple[TradeRecord, ...]', portfolio_snapshots: 'tuple[EquityPoint, ...]', unpriced_assets: 'Mapping[str, UnpricedAsset]', id_position: 'IdStreamPosition', dropped: 'Mapping[str, int]' = <factory>, schema_version: 'int' = 8) -> None",
      "READABLE_PIPELINE_SCHEMAS": "value builtins.tuple",
      "RETAINED_LOGS": "value builtins.tuple",
      "RiskEventRecord": "class alphalab.runtime.snapshot.RiskEventRecord(event_type: 'str', event: 'RiskEvent') -> None",
      "RuntimeObjects": "class alphalab.runtime.snapshot.RuntimeObjects(sizing_model: 'object', simulator: 'object', strategies: 'Mapping[str, StrategyProtocol]', instruments: 'InstrumentRegistry | None' = None) -> None",
      "StrategyEventRecord": "class alphalab.runtime.snapshot.StrategyEventRecord(event_type: 'str', event: 'StrategyRuntimeEvent') -> None",
      "StrategyRecord": "class alphalab.runtime.snapshot.StrategyRecord(strategy_id: 'str', status: 'StrategyStatus', config: 'Any', subscriptions: 'tuple[str, ...]', last_error: 'str | None', instance_type: 'str', state: 'StrategyStateRecord | _NotAsked | None' = NOT_ASKED, started: 'bool' = False) -> None",
      "StrategyStateRecord": "class alphalab.runtime.snapshot.StrategyStateRecord(payload: 'Any', version: 'int') -> None",
      "capture": "function alphalab.runtime.snapshot.capture(state: 'ExecutionPipelineState') -> 'PipelineSnapshot'",
      "from_primitives": "function alphalab.runtime.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'PipelineSnapshot'",
      "restore": "function alphalab.runtime.snapshot.restore(snapshot: 'PipelineSnapshot', objects: 'RuntimeObjects') -> 'ExecutionPipelineState'"
    },
    "alphalab.scenario": {
      "COMMODITY_SHOCK_2022": "value alphalab.scenario.library.ScenarioDefinition",
      "COVID_CRASH_2020": "value alphalab.scenario.library.ScenarioDefinition",
      "CRISIS_2008": "value alphalab.scenario.library.ScenarioDefinition",
      "HISTORICAL_SCENARIOS": "value builtins.dict",
      "RATES_REPRICING_2022": "value alphalab.scenario.library.ScenarioDefinition",
      "Requirement": "class alphalab.scenario.library.Requirement(key: 'str', kind: 'ShockKind', description: 'str') -> None",
      "Scenario": "class alphalab.scenario.scenario.Scenario(name: 'str', shocks: 'tuple[Shock, ...]') -> None",
      "ScenarioDefinition": "class alphalab.scenario.library.ScenarioDefinition(name: 'str', window: 'str', source_note: 'str', requirements: 'tuple[Requirement, ...]') -> None",
      "ScenarioError": "class alphalab.scenario.exceptions.ScenarioError",
      "ScenarioExposure": "class alphalab.scenario.exposure.ScenarioExposure(asset_id: 'str', quantity: 'Decimal', price: 'Decimal', currency: 'str', volatility: 'float | None' = None, available_liquidity: 'Decimal | None' = None, sector: 'str | None' = None) -> None",
      "ScenarioResult": "class alphalab.scenario.scenario.ScenarioResult(scenario_name: 'str', scenario_identity: 'str', base_state: 'ScenarioState', shocked_state: 'ScenarioState', base_value: 'Decimal', shocked_value: 'Decimal', change_by_asset: 'Mapping[str, Decimal]', reached: 'tuple[int, ...]') -> None",
      "ScenarioState": "class alphalab.scenario.exposure.ScenarioState(exposures: 'tuple[ScenarioExposure, ...]', base_currency: 'str', rates: 'Mapping[str, Decimal]') -> None",
      "ScenarioValidationError": "class alphalab.scenario.exceptions.ScenarioValidationError",
      "ScopeKind": "enum alphalab.scenario.shock.ScopeKind[ALL, ASSETS, SECTOR, CURRENCY]",
      "Shock": "class alphalab.scenario.shock.Shock(kind: 'ShockKind', magnitude: 'Decimal', scope: 'ShockScope') -> None",
      "ShockKind": "enum alphalab.scenario.shock.ShockKind[PRICE, VOLATILITY, FX, LIQUIDITY]",
      "ShockScope": "class alphalab.scenario.shock.ShockScope(kind: 'ScopeKind', selector: 'tuple[str, ...]' = ()) -> None",
      "UnsupportedShockError": "class alphalab.scenario.exceptions.UnsupportedShockError",
      "apply_all": "function alphalab.scenario.scenario.apply_all(scenarios: 'Sequence[Scenario]', state: 'ScenarioState') -> 'tuple[ScenarioResult, ...]'",
      "commodity_shock": "function alphalab.scenario.library.commodity_shock(magnitude: 'Decimal', *asset_ids: 'str') -> 'Scenario'",
      "everything": "function alphalab.scenario.shock.everything() -> 'ShockScope'",
      "flash_crash": "function alphalab.scenario.library.flash_crash(magnitude: 'Decimal', scope: 'ShockScope | None' = None) -> 'Scenario'",
      "from_positions": "function alphalab.scenario.exposure.from_positions(positions: 'Sequence[tuple[str, Decimal, Decimal, str]]', base_currency: 'str', rates: 'Mapping[str, Decimal] | None' = None) -> 'ScenarioState'",
      "fx_shock": "function alphalab.scenario.library.fx_shock(magnitude: 'Decimal', *currencies: 'str') -> 'Scenario'",
      "of_assets": "function alphalab.scenario.shock.of_assets(*asset_ids: 'str') -> 'ShockScope'",
      "of_currency": "function alphalab.scenario.shock.of_currency(*currencies: 'str') -> 'ShockScope'",
      "of_sector": "function alphalab.scenario.shock.of_sector(*sectors: 'str') -> 'ShockScope'",
      "rate_shock": "function alphalab.scenario.library.rate_shock(magnitude: 'Decimal', scope: 'ShockScope') -> 'Scenario'",
      "scenario": "function alphalab.scenario.scenario.scenario(name: 'str', *, price_shock: 'Decimal | None' = None, volatility_shock: 'Decimal | None' = None, fx_shock: 'Decimal | None' = None, liquidity_shock: 'Decimal | None' = None, scope: 'ShockScope | None' = None) -> 'Scenario'",
      "sector_shock": "function alphalab.scenario.library.sector_shock(magnitude: 'Decimal', *sectors: 'str') -> 'Scenario'"
    },
    "alphalab.scheduler": {
      "BacktestClock": "class alphalab.scheduler.clock.BacktestClock(_current_time: float) -> None",
      "CRON_SEARCH_DAYS": "value builtins.int",
      "ClockAdvanced": "class alphalab.scheduler.events.ClockAdvanced(event_id: str, timestamp: float, old_time: float, new_time: float) -> None",
      "ClockProtocol": "class alphalab.common.time.ClockProtocol(*args, **kwargs)",
      "ClockReset": "class alphalab.scheduler.events.ClockReset(event_id: str, timestamp: float, reset_time: float) -> None",
      "ClockState": "class alphalab.scheduler.clock.ClockState(current_time: float) -> None",
      "CronSchedule": "class alphalab.scheduler.cron.CronSchedule(expression: 'str', zone: 'str') -> None",
      "InvalidClockStateError": "class alphalab.scheduler.exceptions.InvalidClockStateError",
      "SESSION_SCHEDULES": "value builtins.frozenset",
      "ScheduleType": "enum alphalab.scheduler.schedule.ScheduleType[ONE_SHOT, REPEATING, INTERVAL, CRON, MANUAL, SESSION_OPEN, SESSION_CLOSE]",
      "ScheduledSession": "class alphalab.scheduler.session.ScheduledSession(session_id: str, start_time: float, end_time: float, phase: alphalab.scheduler.session.SessionPhase) -> None",
      "SchedulerEngine": "class alphalab.scheduler.engine.SchedulerEngine()",
      "SchedulerError": "class alphalab.scheduler.exceptions.SchedulerError",
      "SchedulerEvent": "class alphalab.scheduler.events.SchedulerEvent(event_id: str, timestamp: float) -> None",
      "SchedulerResolver": "class alphalab.scheduler.scheduler.SchedulerResolver()",
      "SchedulerState": "class alphalab.scheduler.state.SchedulerState(clock: alphalab.scheduler.clock.ClockState, timers: alphalab.common.persistent_map.PersistentMap[str, alphalab.scheduler.timer.Timer] = <factory>, active_sessions: alphalab.common.persistent_map.PersistentMap[str, alphalab.scheduler.session.ScheduledSession] = <factory>, events: alphalab.common.append_log.AppendOnlyLog[alphalab.scheduler.events.SchedulerEvent] = <factory>) -> None",
      "SchedulerValidationError": "class alphalab.scheduler.exceptions.SchedulerValidationError",
      "SessionEnded": "class alphalab.scheduler.events.SessionEnded(event_id: str, timestamp: float, session_id: str) -> None",
      "SessionPhase": "enum alphalab.scheduler.session.SessionPhase[PRE_MARKET, REGULAR_SESSION, POST_MARKET, CLOSED]",
      "SessionStarted": "class alphalab.scheduler.events.SessionStarted(event_id: str, timestamp: float, session_id: str, phase: str) -> None",
      "SystemClock": "class alphalab.scheduler.clock.SystemClock()",
      "Timer": "class alphalab.scheduler.timer.Timer(timer_id: str, target_timestamp: float, schedule_type: alphalab.scheduler.schedule.ScheduleType, interval: float | None = None, cron: alphalab.scheduler.cron.CronSchedule | None = None, metadata: collections.abc.Mapping[str, Any] | None = None, calendar: alphalab.data.calendar.MarketCalendar | None = None) -> None",
      "TimerCancelled": "class alphalab.scheduler.events.TimerCancelled(event_id: str, timestamp: float, timer_id: str) -> None",
      "TimerScheduled": "class alphalab.scheduler.events.TimerScheduled(event_id: str, timestamp: float, timer_id: str, trigger_time: float, schedule_type: str) -> None",
      "TimerTriggered": "class alphalab.scheduler.events.TimerTriggered(event_id: str, timestamp: float, timer_id: str) -> None",
      "VirtualClock": "class alphalab.scheduler.clock.VirtualClock(_current_time: float) -> None",
      "active_sessions": "function alphalab.scheduler.views.active_sessions(state: alphalab.scheduler.state.SchedulerState) -> collections.abc.Sequence[alphalab.scheduler.session.ScheduledSession]",
      "cron_timer": "function alphalab.scheduler.scheduler.cron_timer(timer_id: str, cron: alphalab.scheduler.cron.CronSchedule, after: float, metadata: dict[str, object] | None = None) -> alphalab.scheduler.timer.Timer",
      "current_time": "function alphalab.scheduler.views.current_time(state: alphalab.scheduler.state.SchedulerState) -> float",
      "is_session_boundary": "function alphalab.scheduler.scheduler.is_session_boundary(calendar: alphalab.data.calendar.MarketCalendar, instant: float, kind: alphalab.scheduler.schedule.ScheduleType) -> bool",
      "next_session_boundary": "function alphalab.scheduler.scheduler.next_session_boundary(calendar: alphalab.data.calendar.MarketCalendar, after: float, kind: alphalab.scheduler.schedule.ScheduleType) -> float | None",
      "next_timer": "function alphalab.scheduler.views.next_timer(state: alphalab.scheduler.state.SchedulerState) -> alphalab.scheduler.timer.Timer | None",
      "scheduled_timers": "function alphalab.scheduler.views.scheduled_timers(state: alphalab.scheduler.state.SchedulerState) -> collections.abc.Sequence[alphalab.scheduler.timer.Timer]",
      "session_timer": "function alphalab.scheduler.scheduler.session_timer(timer_id: str, kind: alphalab.scheduler.schedule.ScheduleType, calendar: alphalab.data.calendar.MarketCalendar, after: float, metadata: dict[str, object] | None = None) -> alphalab.scheduler.timer.Timer",
      "validate_timer": "function alphalab.scheduler.validation.validate_timer(timer: alphalab.scheduler.timer.Timer, current_time: float) -> None"
    },
    "alphalab.strategy": {
      "ADAPTIVE_CONFIGURATION_SCHEME": "value builtins.str",
      "ADAPTIVE_OBSERVATION_SCHEME": "value builtins.str",
      "ADAPTIVE_REPLAY_SCHEME": "value builtins.str",
      "ADAPTIVE_STATE_SCHEME": "value builtins.str",
      "ADAPTIVE_STRATEGY_STATE_VERSION": "value builtins.int",
      "AdaptationMode": "enum alphalab.strategy.adaptive.AdaptationMode[LEARNING, FROZEN]",
      "AdaptiveConfiguration": "class alphalab.strategy.adaptive.AdaptiveConfiguration(name: 'str', rule_id: 'str', rule_version: 'int', inputs: 'tuple[str, ...]', parameters: 'Mapping[str, float]', cadence: 'UpdateCadence', cadence_every: 'int | None', cadence_seconds: 'float | None', decision_timing: 'DecisionTiming', warmup: 'int') -> None",
      "AdaptiveDecision": "class alphalab.strategy.adaptive.AdaptiveDecision(observation_id: 'str', state_id: 'str', outputs: 'Mapping[str, float]', withheld: 'bool') -> None",
      "AdaptiveObservation": "class alphalab.strategy.adaptive.AdaptiveObservation(timestamp: 'float', sequence: 'int', stream: 'str', values: 'Mapping[str, float]') -> None",
      "AdaptiveOrderingError": "class alphalab.strategy.exceptions.AdaptiveOrderingError",
      "AdaptiveReplay": "class alphalab.strategy.adaptive.AdaptiveReplay(configuration: 'AdaptiveConfiguration', mode: 'AdaptationMode', initial: 'AdaptiveState', stream_id: 'str', observations: 'int', transitions: 'tuple[AdaptiveTransition, ...]', decisions: 'tuple[AdaptiveDecision, ...]', final: 'AdaptiveState') -> None",
      "AdaptiveRule": "class alphalab.strategy.adaptive.AdaptiveRule(*args, **kwargs)",
      "AdaptiveState": "class alphalab.strategy.adaptive.AdaptiveState(configuration_id: 'str', version: 'int', observations: 'int', payload: 'Mapping[str, StateValue]', last_timestamp: 'float | None', last_sequence: 'int | None', last_adapted_at: 'float | None', lineage: 'str') -> None",
      "AdaptiveStateError": "class alphalab.strategy.exceptions.AdaptiveStateError",
      "AdaptiveStep": "class alphalab.strategy.adaptive.AdaptiveStep(state: 'AdaptiveState', transition: 'AdaptiveTransition', decision: 'AdaptiveDecision') -> None",
      "AdaptiveStrategy": "class alphalab.strategy.adaptive_strategy.AdaptiveStrategy(strategy_id: 'str', configuration: 'AdaptiveConfiguration', rule: 'AdaptiveRule', mode: 'AdaptationMode', initial: 'AdaptiveState | None') -> 'None'",
      "AdaptiveTransition": "class alphalab.strategy.adaptive.AdaptiveTransition(observation_id: 'str', kind: 'TransitionKind', before: 'str', after: 'str') -> None",
      "BaseStrategy": "class alphalab.strategy.protocol.BaseStrategy()",
      "ClockProtocol": "class alphalab.common.time.ClockProtocol(*args, **kwargs)",
      "DecisionTiming": "enum alphalab.strategy.adaptive.DecisionTiming[BEFORE_UPDATE, AFTER_UPDATE]",
      "DiscardingLogger": "class alphalab.strategy.context.DiscardingLogger()",
      "Dispatcher": "class alphalab.strategy.dispatcher.Dispatcher()",
      "DuplicateStrategyError": "class alphalab.strategy.registry.DuplicateStrategyError",
      "ExponentialMeanRule": "class alphalab.strategy.adaptive_rules.ExponentialMeanRule() -> None",
      "FillEvent": "class alphalab.strategy.events.FillEvent(event_id: str, timestamp: float, order_id: str, instrument: str, fill_quantity: decimal.Decimal, fill_price: decimal.Decimal, side: str = '', attributed_quantity: decimal.Decimal | None = None, execution_id: str = '') -> None",
      "FixedClock": "class alphalab.strategy.context.FixedClock(instant: float) -> None",
      "HistoryAccessorProtocol": "class alphalab.strategy.context.HistoryAccessorProtocol(*args, **kwargs)",
      "HookExecutionError": "class alphalab.strategy.exceptions.HookExecutionError",
      "Intent": "class alphalab.strategy.events.Intent(strategy_id: str, instrument: str, target: decimal.Decimal, strength: decimal.Decimal = Decimal('1.0'), horizon: str = 'default', terms: alphalab.common.order_terms.OrderTerms = OrderTerms(order_type=<OrderType.MARKET: 'market'>, limit_price=None, stop_price=None, time_in_force=<TimeInForce.DAY: 'day'>, expire_at=None), correlation_id: str = '', timestamp: float = 0.0, metadata: collections.abc.Mapping[str, str] = <factory>, kind: alphalab.strategy.events.IntentKind = <IntentKind.DELTA: 'delta'>) -> None",
      "IntentKind": "enum alphalab.strategy.events.IntentKind[DELTA, TARGET_QUANTITY, TARGET_WEIGHT]",
      "InvalidIntentError": "class alphalab.strategy.exceptions.InvalidIntentError",
      "InvalidTransitionError": "class alphalab.strategy.exceptions.InvalidTransitionError",
      "LifecycleTransitioned": "class alphalab.strategy.events.LifecycleTransitioned(event_id: str, timestamp: float, strategy_id: str, old_state: str, new_state: str, reason: str = '') -> None",
      "MarketViewProtocol": "class alphalab.strategy.context.MarketViewProtocol(*args, **kwargs)",
      "NoHistory": "class alphalab.strategy.context.NoHistory() -> None",
      "NoMarket": "class alphalab.strategy.context.NoMarket() -> None",
      "NoOrders": "class alphalab.strategy.context.NoOrders() -> None",
      "NoPortfolio": "class alphalab.strategy.context.NoPortfolio() -> None",
      "NoRiskView": "class alphalab.strategy.context.NoRiskView() -> None",
      "NoUniverse": "class alphalab.strategy.context.NoUniverse() -> None",
      "ObservationReceived": "class alphalab.strategy.events.ObservationReceived(event_id: str, timestamp: float, delivery_id: str = '', subject: str = '', record: alphalab.common.point_in_time.StampedRecord | None = None) -> None",
      "ObservationStrategyProtocol": "class alphalab.strategy.protocol.ObservationStrategyProtocol(*args, **kwargs)",
      "OrderEvent": "class alphalab.strategy.events.OrderEvent(event_id: str, timestamp: float, order_id: str, instrument: str, status: str, reason: str = '', quantity: decimal.Decimal | None = None, filled_quantity: decimal.Decimal | None = None) -> None",
      "OrderFacadeProtocol": "class alphalab.strategy.context.OrderFacadeProtocol(*args, **kwargs)",
      "PortfolioSnapshotProtocol": "class alphalab.strategy.context.PortfolioSnapshotProtocol(*args, **kwargs)",
      "RecursiveLeastSquaresRule": "class alphalab.strategy.adaptive_rules.RecursiveLeastSquaresRule() -> None",
      "RiskViewProtocol": "class alphalab.strategy.context.RiskViewProtocol(*args, **kwargs)",
      "RuntimeState": "class alphalab.strategy.state.RuntimeState(strategies: 'Mapping[str, StrategyState]' = <factory>, events: 'tuple[StrategyRuntimeEvent, ...]' = <factory>) -> None",
      "RuntimeSupervisor": "class alphalab.strategy.supervisor.RuntimeSupervisor()",
      "SUBSCRIBE_ALL": "value builtins.str",
      "ScopedLoggerProtocol": "class alphalab.strategy.context.ScopedLoggerProtocol(*args, **kwargs)",
      "SliceClosed": "class alphalab.strategy.events.SliceClosed(event_id: str, timestamp: float, assets: tuple[str, ...] = ()) -> None",
      "SliceStrategyProtocol": "class alphalab.strategy.protocol.SliceStrategyProtocol(*args, **kwargs)",
      "StateValue": "alias StateValue",
      "StrategyClassRegistry": "class alphalab.strategy.registry.StrategyClassRegistry(registrations: 'PersistentMap[str, StrategyRegistration]' = <factory>) -> None",
      "StrategyContext": "class alphalab.strategy.context.StrategyContext(portfolio: alphalab.strategy.context.PortfolioSnapshotProtocol, market: alphalab.strategy.context.MarketViewProtocol, clock: alphalab.common.time.ClockProtocol, logger: alphalab.strategy.context.ScopedLoggerProtocol, risk_view: alphalab.strategy.context.RiskViewProtocol, config: Any, orders: alphalab.strategy.context.OrderFacadeProtocol, history: alphalab.strategy.context.HistoryAccessorProtocol = <factory>, universe: alphalab.strategy.context.UniverseProtocol = <factory>) -> None",
      "StrategyDeclaration": "class alphalab.strategy.registry.StrategyDeclaration(*args, **kwargs)",
      "StrategyDefinition": "class alphalab.strategy.definition.StrategyDefinition(strategy_id: 'str', name: 'str', version: 'str', author: 'str', description: 'str', parameters: 'Mapping[str, ParamValue]' = <factory>, metadata: 'Mapping[str, str]' = <factory>) -> None",
      "StrategyEngine": "class alphalab.strategy.engine.StrategyEngine()",
      "StrategyFactory": "class alphalab.strategy.registry.StrategyFactory(*args, **kwargs)",
      "StrategyProtocol": "class alphalab.strategy.protocol.StrategyProtocol(*args, **kwargs)",
      "StrategyRegistration": "class alphalab.strategy.registry.StrategyRegistration(strategy_id: 'str', factory: 'StrategyFactory', qualified_name: 'str') -> None",
      "StrategyRuntimeError": "class alphalab.strategy.exceptions.StrategyRuntimeError",
      "StrategyRuntimeEvent": "class alphalab.strategy.events.StrategyRuntimeEvent(event_id: str, timestamp: float) -> None",
      "StrategyState": "class alphalab.strategy.state.StrategyState(strategy_id: 'str', status: 'StrategyStatus', instance: 'StrategyProtocol', config: 'Any' = None, subscriptions: 'frozenset[str]' = <factory>, last_error: 'str | None' = None, started: 'bool' = False) -> None",
      "StrategyStateProtocol": "class alphalab.strategy.protocol.StrategyStateProtocol(*args, **kwargs)",
      "StrategyStatus": "enum alphalab.strategy.state.StrategyStatus[CREATED, CONFIGURED, INITIALIZED, SUBSCRIBED, RUNNING, PAUSED, STOPPING, STOPPED, FAILED, DISPOSED]",
      "StrategyValidationError": "class alphalab.strategy.exceptions.StrategyValidationError",
      "Subscriptions": "class alphalab.strategy.subscription.Subscriptions(everything: 'bool', topics: 'frozenset[Topic]', scoped: 'frozenset[tuple[Topic, str]]') -> None",
      "TimerEvent": "class alphalab.strategy.events.TimerEvent(event_id: str, timestamp: float, timer_id: str, schedule_type: str) -> None",
      "Topic": "enum alphalab.strategy.subscription.Topic[TICKS, QUOTES, TRADES, BARS, FILLS, ORDERS, TIMERS, SLICES, OBSERVATIONS]",
      "TrailingZScoreRule": "class alphalab.strategy.adaptive_rules.TrailingZScoreRule() -> None",
      "TransitionKind": "enum alphalab.strategy.adaptive.TransitionKind[ADAPTED, OBSERVED, FROZEN]",
      "UniverseProtocol": "class alphalab.strategy.context.UniverseProtocol(*args, **kwargs)",
      "UnknownStrategyError": "class alphalab.strategy.registry.UnknownStrategyError",
      "UpdateCadence": "enum alphalab.strategy.adaptive.UpdateCadence[EVERY_OBSERVATION, EVERY_N_OBSERVATIONS, MINIMUM_INTERVAL]",
      "active_strategies": "function alphalab.strategy.views.active_strategies(state: alphalab.strategy.state.RuntimeState) -> collections.abc.Sequence[alphalab.strategy.state.StrategyState]",
      "apply_update": "function alphalab.strategy.adaptive.apply_update(state: 'AdaptiveState', observation: 'AdaptiveObservation', configuration: 'AdaptiveConfiguration', rule: 'AdaptiveRule', mode: 'AdaptationMode') -> 'AdaptiveStep'",
      "canonical_configuration_key": "function alphalab.strategy.adaptive.canonical_configuration_key(configuration: 'AdaptiveConfiguration') -> 'str'",
      "checkpoint": "function alphalab.strategy.adaptive.checkpoint(state: 'AdaptiveState') -> 'dict[str, Any]'",
      "context_factory": "function alphalab.strategy.context.context_factory(clock: alphalab.common.time.ClockProtocol, logger: alphalab.strategy.context.ScopedLoggerProtocol) -> collections.abc.Callable[[str], alphalab.strategy.context.StrategyContext]",
      "create_runtime": "function alphalab.strategy.runtime.create_runtime() -> alphalab.strategy.state.RuntimeState",
      "defines_on_observation": "function alphalab.strategy.protocol.defines_on_observation(strategy: object) -> bool",
      "defines_on_slice": "function alphalab.strategy.protocol.defines_on_slice(strategy: object) -> bool",
      "failed_strategies": "function alphalab.strategy.views.failed_strategies(state: alphalab.strategy.state.RuntimeState) -> collections.abc.Sequence[alphalab.strategy.state.StrategyState]",
      "get_strategy": "function alphalab.strategy.views.get_strategy(state: alphalab.strategy.state.RuntimeState, strategy_id: str) -> alphalab.strategy.state.StrategyState | None",
      "initial_state": "function alphalab.strategy.adaptive.initial_state(configuration: 'AdaptiveConfiguration', rule: 'AdaptiveRule') -> 'AdaptiveState'",
      "instances_for": "function alphalab.strategy.registry.instances_for(registry: 'StrategyClassRegistry', declarations: 'Iterable[StrategyDeclaration]') -> 'dict[str, StrategyProtocol]'",
      "numeric_parameters": "function alphalab.strategy.definition.numeric_parameters(parameters: 'Mapping[str, ParamValue]') -> 'Mapping[str, float]'",
      "observation_stream": "function alphalab.strategy.adaptive.observation_stream(stream: 'str', rows: 'Iterable[tuple[float, Mapping[str, float]]]', *, first_sequence: 'int') -> 'tuple[AdaptiveObservation, ...]'",
      "register_strategy": "function alphalab.strategy.runtime.register_strategy(state: alphalab.strategy.state.RuntimeState, strategy_id: str, instance: alphalab.strategy.protocol.StrategyProtocol) -> alphalab.strategy.state.RuntimeState",
      "replay_updates": "function alphalab.strategy.adaptive.replay_updates(configuration: 'AdaptiveConfiguration', rule: 'AdaptiveRule', observations: 'Iterable[AdaptiveObservation]', mode: 'AdaptationMode', initial: 'AdaptiveState | None' = None) -> 'AdaptiveReplay'",
      "restore": "function alphalab.strategy.adaptive.restore(payload: 'Mapping[str, Any]', configuration: 'AdaptiveConfiguration', rule: 'AdaptiveRule') -> 'AdaptiveState'",
      "runtime_for": "function alphalab.strategy.registry.runtime_for(registry: 'StrategyClassRegistry', declarations: 'Iterable[StrategyDeclaration]') -> 'RuntimeState'",
      "start_strategy": "function alphalab.strategy.runtime.start_strategy(state: alphalab.strategy.state.RuntimeState, strategy_id: str, instance: alphalab.strategy.protocol.StrategyProtocol, *, config: Any, subscriptions: collections.abc.Iterable[str], at: float) -> alphalab.strategy.state.RuntimeState",
      "validate_intent": "function alphalab.strategy.validation.validate_intent(intent: alphalab.strategy.events.Intent) -> None"
    }
  },
  "shared_names": {
    "Bar": {
      "bound_to": [
        "class alphalab.data.feed.Bar(symbol: str, timestamp: float, open: float, high: float, low: float, close: float, volume: float) -> None",
        "class alphalab.market.bar.Bar(asset_id: 'str', timestamp: 'float', open: 'Decimal', high: 'Decimal', low: 'Decimal', close: 'Decimal', volume: 'Decimal', vwap: 'Decimal | None', trade_count: 'int | None', timeframe: 'TimeFrame') -> None"
      ],
      "reason": "Wire and domain: data.feed.Bar is an OHLCV aggregate as a provider reported it (a provider symbol, float prices); market.bar.Bar is the domain bar the execution path consumes (an asset id, Decimal prices, an optional vwap and trade count). One is converted into the other at ingestion; they sit on opposite sides of that conversion."
    },
    "CashFlow": {
      "bound_to": [
        "class alphalab.macro.bond.CashFlow(payment_date: 'date', amount: 'Decimal', is_principal: 'bool') -> None",
        "class alphalab.portfolio.corporate_actions.CashFlow(kind: 'CashFlowKind', amount: 'Decimal', currency: 'str', asset_id: 'str' = '', reference: 'str' = '') -> None"
      ],
      "reason": "Two cash flows of two instruments: macro.bond.CashFlow is one payment a bond's schedule makes; portfolio.corporate_actions.CashFlow is cash a holding earned or cost without a trade (a dividend, a fee) booked to an account."
    },
    "Dataset": {
      "bound_to": [
        "class alphalab.data.dataset.Dataset(metadata: 'DatasetMetadata', schema: 'DatasetSchema', quality: 'QualityReport', records: 'tuple[CanonicalRecord, ...]' = <factory>, provenance: 'DatasetProvenance | None' = None, quality_detail: 'DataQualityReport | None' = None) -> None",
        "class alphalab.ml.dataset.Dataset(feature_names: tuple[str, ...], x: tuple[tuple[float, ...], ...], y: tuple[float, ...], asset_ids: tuple[str, ...]) -> None"
      ],
      "reason": "A canonical price series and a design matrix: data.dataset.Dataset is one immutable, versioned dataset of market records; ml.dataset.Dataset is features and a target ready for a model. Section 13 of the shared-names test."
    },
    "ExposureUpdated": {
      "bound_to": [
        "class alphalab.portfolio_optimizer.events.ExposureUpdated(event_id: str, timestamp: float, portfolio_id: str) -> None",
        "class alphalab.risk.events.ExposureUpdated(event_id: str, timestamp: float, gross_exposure: decimal.Decimal, net_exposure: decimal.Decimal) -> None"
      ],
      "reason": "Two engines' notifications: risk.events.ExposureUpdated carries the gross and net exposure the pre-trade gate computed and is persisted under the risk event tags; portfolio_optimizer.events.ExposureUpdated says a constructed portfolio's exposure was recomputed. Renaming the persisted one is a format change (tests/regression/test_persisted_enum_names.py)."
    },
    "InvalidTransitionError": {
      "bound_to": [
        "class alphalab.oms.exceptions.InvalidTransitionError",
        "class alphalab.strategy.exceptions.InvalidTransitionError"
      ],
      "reason": "Each state machine's own refusal, under its own package's error base: oms.exceptions.InvalidTransitionError for an order's lifecycle, strategy.exceptions.InvalidTransitionError for a strategy instance's. Catching one deliberately does not catch the other."
    },
    "MarketDataError": {
      "bound_to": [
        "class alphalab.market.exceptions.MarketDataError",
        "class alphalab.marketdata.exceptions.MarketDataError"
      ],
      "reason": "Each package's error base: market.exceptions.MarketDataError for the market data engine, marketdata.exceptions.MarketDataError for the transports that feed it."
    },
    "OrderAccepted": {
      "bound_to": [
        "class alphalab.broker.events.OrderAccepted(event_id: str, timestamp: float, broker_order_id: str) -> None",
        "class alphalab.oms.events.OrderAccepted(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId) -> None"
      ],
      "reason": "Two sides of one order: oms.events.OrderAccepted is the OMS's lifecycle transition; broker.events.OrderAccepted is a venue's acknowledgement, which the OMS may or may not then reflect. Each is persisted under its own subsystem's event tags, so neither can be renamed without a schema step."
    },
    "OrderBook": {
      "bound_to": [
        "class alphalab.data.feed.OrderBook(symbol: str, timestamp: float, bids: tuple[alphalab.data.feed.OrderBookLevel, ...] = <factory>, asks: tuple[alphalab.data.feed.OrderBookLevel, ...] = <factory>) -> None",
        "class alphalab.oms.book.OrderBook(_orders: alphalab.common.persistent_map.PersistentMap[alphalab.oms.ids.OrderId, alphalab.oms.order.Order] = <factory>, _by_asset: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId]] = <factory>, _by_strategy: alphalab.common.persistent_map.PersistentMap[str, alphalab.common.persistent_map.PersistentSet[alphalab.oms.ids.OrderId]] = <factory>) -> None"
      ],
      "reason": "My working orders and the market's resting size: oms.book.OrderBook indexes the OMS's own orders; data.feed.OrderBook is a provider's depth snapshot. They share no operation (tests/regression/test_shared_names_stay_distinct.py, section 1)."
    },
    "OrderBookLevel": {
      "bound_to": [
        "class alphalab.data.feed.OrderBookLevel(price: float, size: float) -> None",
        "class alphalab.market.level.OrderBookLevel(price: decimal.Decimal, size: decimal.Decimal, orders: int) -> None"
      ],
      "reason": "Wire and domain: data.feed.OrderBookLevel is one level of a provider's depth record (no order count); market.level.OrderBookLevel is the domain level of a market book snapshot."
    },
    "OrderCancelled": {
      "bound_to": [
        "class alphalab.broker.events.OrderCancelled(event_id: str, timestamp: float, broker_order_id: str) -> None",
        "class alphalab.oms.events.OrderCancelled(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId) -> None"
      ],
      "reason": "The OMS's lifecycle transition and a venue's cancel confirmation: two events, each persisted under its own subsystem's tags. See OrderAccepted."
    },
    "OrderId": {
      "bound_to": [
        "class alphalab.oms.ids.OrderId(value: 'uuid.UUID') -> None",
        "newtype alphalab.core.ids.OrderId"
      ],
      "reason": "Two representations of one identity across one boundary: core.ids.OrderId is the text a fill and a trade record carry and a payload persists; oms.ids.OrderId is the OMS's typed key, a UUID whose hash is computed once (ledger PRF-006). The runtime converts between them in alphalab.runtime.execution_adapters."
    },
    "OrderRejected": {
      "bound_to": [
        "class alphalab.broker.events.OrderRejected(event_id: str, timestamp: float, broker_order_id: str, reason: str) -> None",
        "class alphalab.oms.events.OrderRejected(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, reason: str) -> None"
      ],
      "reason": "The OMS's refusal of an order and a venue's: two events, each persisted under its own subsystem's tags. See OrderAccepted."
    },
    "OrderSubmitted": {
      "bound_to": [
        "class alphalab.broker.events.OrderSubmitted(event_id: str, timestamp: float, broker_order_id: str, oms_order_id: str) -> None",
        "class alphalab.oms.events.OrderSubmitted(event_id: str, timestamp: float, order_id: alphalab.oms.ids.OrderId, order: alphalab.oms.order.Order) -> None"
      ],
      "reason": "The OMS's record that an order was submitted and the broker boundary's record that it reached a venue: two events, each persisted under its own subsystem's tags. See OrderAccepted."
    },
    "PortfolioEngine": {
      "bound_to": [
        "class alphalab.portfolio.engine.PortfolioEngine()",
        "class alphalab.portfolio_optimizer.engine.PortfolioEngine()"
      ],
      "reason": "Accounting and construction: portfolio.PortfolioEngine keeps the book from fills; portfolio_optimizer.PortfolioEngine assembles target weights. Only the first is reachable from the execution path. Section 2 of the shared-names test."
    },
    "PortfolioEvent": {
      "bound_to": [
        "class alphalab.portfolio.events.PortfolioEvent(timestamp: float, account_id: str) -> None",
        "class alphalab.portfolio_optimizer.events.PortfolioEvent(event_id: str, timestamp: float) -> None"
      ],
      "reason": "Each engine's event base: portfolio.events.PortfolioEvent is the base of what the accounting book records, and its subclasses are persisted under the portfolio event tags; portfolio_optimizer.events.PortfolioEvent is the construction engine's base, which no snapshot carries."
    },
    "PortfolioSnapshot": {
      "bound_to": [
        "class alphalab.analytics.engine.PortfolioSnapshot(timestamp: float, total_equity: decimal.Decimal, cash: decimal.Decimal, long_exposure: decimal.Decimal, short_exposure: decimal.Decimal) -> None",
        "class alphalab.portfolio.snapshot.PortfolioSnapshot(account: 'Account', balances: 'Mapping[str, Decimal]', reserved: 'Mapping[str, Decimal]', positions: 'tuple[Position, ...]', transactions: 'tuple[Transaction, ...]', events: 'tuple[PortfolioEventRecord, ...]', realized_pnl: 'Mapping[str, Decimal]', commission_paid: 'Mapping[str, Decimal]', pending_marks: 'tuple[str, ...]', schema_version: 'int' = 5) -> None"
      ],
      "reason": "Two pictures of a portfolio for two readers: analytics.PortfolioSnapshot is one point of an equity curve (timestamp, equity, cash, exposures) that a report reads; portfolio.snapshot.PortfolioSnapshot is the persisted, versioned capture of the whole accounting state that a restore reads."
    },
    "Quote": {
      "bound_to": [
        "class alphalab.data.feed.Quote(symbol: str, timestamp: float, bid: float, ask: float, bid_size: float, ask_size: float) -> None",
        "class alphalab.market.quote.Quote(asset_id: str, timestamp: float, bid: decimal.Decimal, ask: decimal.Decimal, bid_size: decimal.Decimal, ask_size: decimal.Decimal, venue: str, currency: str) -> None"
      ],
      "reason": "Wire and domain: data.feed.Quote is a provider's top of book as reported (a provider symbol, floats); market.quote.Quote is the domain quote the execution path consumes (an asset id, Decimals, a venue and a currency). Converted at ingestion."
    },
    "ReportGenerated": {
      "bound_to": [
        "class alphalab.analytics.events.ReportGenerated(event_id: str, timestamp: float, report_id: str, num_snapshots: int, num_trades: int) -> None",
        "class alphalab.reporting.events.ReportGenerated(event_id: str, timestamp: float, report_id: str, report_type: str) -> None"
      ],
      "reason": "Two reports: analytics.events.ReportGenerated is a performance report compiled on the execution path and persisted under the analytics event tags; reporting.events.ReportGenerated is a document the reporting engine rendered and stored."
    },
    "SessionCalendar": {
      "bound_to": [
        "class alphalab.alt_data.sessions.SessionCalendar(*args, **kwargs)",
        "class alphalab.futures.chain.SessionCalendar(*args, **kwargs)"
      ],
      "reason": "Two narrow protocols, each stating only what its reader needs from a calendar: alt_data's places an instant in a trading day (is_open, next_open, session windows), futures' only asks whether a day is a trading day, for a roll rule. data.calendar.MarketCalendar satisfies both; neither is a calendar. Section 19 of the shared-names test."
    },
    "Split": {
      "bound_to": [
        "class alphalab.data.feed.Split(symbol: str, timestamp: float, ratio: float) -> None",
        "class alphalab.portfolio.corporate_actions.Split(asset_id: 'str', ratio: 'Decimal') -> None"
      ],
      "reason": "Wire and domain: data.feed.Split is a split as a corporate-action feed reports it (symbol, ratio as a float); portfolio.corporate_actions.Split is the action applied to a holding, which also expresses a reverse split and a stock dividend exactly."
    },
    "Trade": {
      "bound_to": [
        "class alphalab.core.trade.Trade(trade_id: alphalab.core.ids.TradeId, asset_id: alphalab.core.ids.AssetId, side: alphalab.core.enums.Side, quantity: decimal.Decimal, average_price: decimal.Decimal, fill_ids: tuple[alphalab.core.ids.FillId, ...], executed_at: float, order_id: alphalab.core.ids.OrderId | None = None) -> None",
        "class alphalab.data.feed.Trade(symbol: str, timestamp: float, price: float, size: float, trade_id: str = '', aggressor: alphalab.data.feed.TradeAggressor | None = None) -> None"
      ],
      "reason": "Two different trades: core.trade.Trade is an execution AlphaLab's own order made, as the accounting records it; data.feed.Trade is a print a provider reported on the tape, anyone's."
    },
    "all_reports": {
      "bound_to": [
        "function alphalab.analytics.views.all_reports(state: alphalab.analytics.state.AnalyticsState) -> tuple[alphalab.analytics.report.PerformanceReport, ...]",
        "function alphalab.execution.views.all_reports(state: alphalab.execution.state.ExecutionState) -> collections.abc.Sequence[alphalab.execution.report.ExecutionReport]"
      ],
      "reason": "Each package's view over its own state: analytics.all_reports(AnalyticsState) returns performance reports, execution.all_reports(ExecutionState) execution reports. The state argument says which."
    },
    "capture": {
      "bound_to": [
        "function alphalab.allocation.snapshot.capture(state: 'AllocationState') -> 'AllocationSnapshot'",
        "function alphalab.backtesting.replay_snapshot.capture(paused: 'PausedReplay') -> 'ReplaySnapshot'",
        "function alphalab.broker.snapshot.capture(state: 'BrokerState', mapping: 'ExternalOrderMap | None' = None, log: 'ReconciliationLog | None' = None) -> 'BrokerSnapshot'",
        "function alphalab.instrument.snapshot.capture(registry: 'InstrumentRegistry') -> 'InstrumentRegistrySnapshot'",
        "function alphalab.lifecycle.snapshot.capture(state: 'LifecycleState') -> 'LifecycleSnapshot'",
        "function alphalab.oms.snapshot.capture(state: 'OMSState') -> 'OMSSnapshot'",
        "function alphalab.portfolio.fx_feed.capture(state: 'FxFeedState') -> 'FxFeedSnapshot'",
        "function alphalab.portfolio.snapshot.capture(state: 'PortfolioState') -> 'PortfolioSnapshot'",
        "function alphalab.runtime.live_snapshot.capture(state: 'LiveRunState') -> 'LiveRunSnapshot'",
        "function alphalab.runtime.run_snapshot.capture(state: 'RunState') -> 'RunSnapshot'",
        "function alphalab.runtime.snapshot.capture(state: 'ExecutionPipelineState') -> 'PipelineSnapshot'"
      ],
      "reason": "One verb over each durable state, which the argument names: each snapshot module's capture(state) projects its own state into its own typed, versioned snapshot (docs/STATE_MODEL.md, 'Durability'), and oms re-exports its module's. The ten follow one convention -- capture, from_primitives, restore -- and are ten functions, not one."
    },
    "checkpoint": {
      "bound_to": [
        "function alphalab.runtime.checkpoint.checkpoint(state: 'RunState', previous: 'CheckpointMark | None' = None) -> 'tuple[str, CheckpointMark]'",
        "function alphalab.strategy.adaptive.checkpoint(state: 'AdaptiveState') -> 'dict[str, Any]'"
      ],
      "reason": "Two checkpoints of two states: runtime.checkpoint(RunState, previous) writes the next incremental checkpoint of a run; strategy.checkpoint(AdaptiveState) gives a learned state's primitives. The argument says which."
    },
    "compare_runs": {
      "bound_to": [
        "function alphalab.experiment_tracking.comparison.compare_runs(tracker: alphalab.experiment_tracking.tracker.ExperimentTracker, run_ids: tuple[str, ...], metric_name: str) -> collections.abc.Mapping[str, float | None]",
        "function alphalab.lifecycle.comparison.compare_runs(left: 'RunObservations', right: 'RunObservations', tolerances: 'Mapping[ComparisonMetric, Tolerance]') -> 'PairComparison'"
      ],
      "reason": "Two comparisons: experiment_tracking.compare_runs reads one metric across tracked runs; lifecycle.compare_runs compares two runs' observations metric by metric under declared tolerances. Different arguments, different results."
    },
    "compute_pnl": {
      "bound_to": [
        "function alphalab.futures.spread.compute_pnl(spread: alphalab.futures.spread.CalendarSpread, entry_prices: collections.abc.Mapping[str, decimal.Decimal], current_prices: collections.abc.Mapping[str, decimal.Decimal]) -> decimal.Decimal",
        "function alphalab.options.strategy.compute_pnl(strategy: alphalab.options.strategy.OptionStrategy, entry_prices: collections.abc.Mapping[str, decimal.Decimal], spot_price: decimal.Decimal) -> decimal.Decimal"
      ],
      "reason": "Each instrument's own P&L: futures.compute_pnl(CalendarSpread, ...) for a calendar spread, options.compute_pnl(OptionStrategy, ...) for an options strategy at a spot price."
    },
    "factor_exposure": {
      "bound_to": [
        "function alphalab.analytics.decomposition.factor_exposure(positions: 'Sequence[PositionRisk]', loadings: 'Mapping[str, Mapping[str, float]]') -> 'Mapping[str, float]'",
        "function alphalab.factor_library.exposure.factor_exposure(weights: 'Mapping[float, Mapping[str, float]]', groups: 'Mapping[str, str] | None' = None) -> 'ExposureReport'"
      ],
      "reason": "A book's and a weighting's: analytics.factor_exposure weights positions' factor loadings; factor_library.factor_exposure aggregates a weighting's exposure by asset and group. Section 39 of the shared-names test."
    },
    "from_primitives": {
      "bound_to": [
        "function alphalab.allocation.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'AllocationSnapshot'",
        "function alphalab.backtesting.replay_snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'ReplaySnapshot'",
        "function alphalab.broker.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'BrokerSnapshot'",
        "function alphalab.instrument.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'InstrumentRegistrySnapshot'",
        "function alphalab.lifecycle.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'LifecycleSnapshot'",
        "function alphalab.oms.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'OMSSnapshot'",
        "function alphalab.portfolio.fx_feed.from_primitives(payload: 'Mapping[str, Any]') -> 'FxFeedSnapshot'",
        "function alphalab.portfolio.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'PortfolioSnapshot'",
        "function alphalab.runtime.live_snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'LiveRunSnapshot'",
        "function alphalab.runtime.run_snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'RunSnapshot'",
        "function alphalab.runtime.snapshot.from_primitives(payload: 'Mapping[str, Any]') -> 'PipelineSnapshot'"
      ],
      "reason": "Each snapshot module's decoder of its own payload, upgrading through its own SchemaHistory and refusing what it does not understand (docs/STATE_MODEL.md); oms re-exports its module's. Which one reads a payload is which state the caller is restoring."
    },
    "list_versions": {
      "bound_to": [
        "function alphalab.feature_store.views.list_versions(state: alphalab.feature_store.state.FeatureStoreState, feature_id: str) -> collections.abc.Sequence[int]",
        "function alphalab.model_registry.registry.list_versions(registry: alphalab.model_registry.registry.ModelRegistry, name: str) -> tuple[alphalab.model_registry.registry.ModelVersion, ...]"
      ],
      "reason": "Each registry's own versions: feature_store.list_versions(FeatureStoreState, feature_id) and model_registry.list_versions(ModelRegistry, name)."
    },
    "register_strategy": {
      "bound_to": [
        "function alphalab.lifecycle.registration.register_strategy(state: 'LifecycleState', name: 'str', definition: 'StrategyDefinition', timestamp: 'float', model: 'ModelRef | None' = None, run_id: 'str | None' = None, tags: 'Mapping[str, str] | None' = None) -> 'tuple[LifecycleState, StrategyVersionRef]'",
        "function alphalab.strategy.runtime.register_strategy(state: alphalab.strategy.state.RuntimeState, strategy_id: str, instance: alphalab.strategy.protocol.StrategyProtocol) -> alphalab.strategy.state.RuntimeState"
      ],
      "reason": "Two registrations: lifecycle.register_strategy records a strategy *version* in the lifecycle registry, checking what it cites; strategy.register_strategy adds a strategy *instance* to a running session."
    },
    "restore": {
      "bound_to": [
        "function alphalab.allocation.snapshot.restore(snapshot: 'AllocationSnapshot') -> 'AllocationState'",
        "function alphalab.backtesting.replay_snapshot.restore(snapshot: 'ReplaySnapshot', objects: 'RunObjects', dataset: 'MarketDataset') -> 'PausedReplay'",
        "function alphalab.broker.snapshot.restore(snapshot: 'BrokerSnapshot') -> 'tuple[BrokerState, ExternalOrderMap, ReconciliationLog]'",
        "function alphalab.instrument.snapshot.restore(snapshot: 'InstrumentRegistrySnapshot') -> 'InstrumentRegistry'",
        "function alphalab.lifecycle.snapshot.restore(snapshot: 'LifecycleSnapshot', models: 'Mapping[str, object]') -> 'LifecycleState'",
        "function alphalab.oms.snapshot.restore(snapshot: 'OMSSnapshot') -> 'OMSState'",
        "function alphalab.portfolio.fx_feed.restore(snapshot: 'FxFeedSnapshot') -> 'FxFeedState'",
        "function alphalab.portfolio.snapshot.restore(snapshot: 'PortfolioSnapshot') -> 'PortfolioState'",
        "function alphalab.runtime.live_snapshot.restore(snapshot: 'LiveRunSnapshot', objects: 'RunObjects') -> 'LiveRunState'",
        "function alphalab.runtime.run_snapshot.restore(snapshot: 'RunSnapshot', objects: 'RunObjects') -> 'RunState'",
        "function alphalab.runtime.snapshot.restore(snapshot: 'PipelineSnapshot', objects: 'RuntimeObjects') -> 'ExecutionPipelineState'",
        "function alphalab.strategy.adaptive.restore(payload: 'Mapping[str, Any]', configuration: 'AdaptiveConfiguration', rule: 'AdaptiveRule') -> 'AdaptiveState'"
      ],
      "reason": "Restorations of different states: each snapshot module's restore(snapshot) rebuilds its own state from its own snapshot -- the pipeline, run and live snapshots taking back the live objects they record, by type and configuration (docs/STATE_MODEL.md) -- and oms re-exports its module's; strategy.restore(payload, configuration, rule) rebuilds an adaptive state from strategy.checkpoint's primitives, or refuses."
    },
    "rollback": {
      "bound_to": [
        "function alphalab.deployment_manager.rollback.rollback(manager: alphalab.deployment_manager.releases.DeploymentManager, environment: str, timestamp: float, actor_id: str = '') -> alphalab.deployment_manager.releases.DeploymentManager",
        "function alphalab.model_registry.rollback.rollback(registry: alphalab.model_registry.registry.ModelRegistry, name: str, timestamp: float) -> alphalab.model_registry.registry.ModelRegistry"
      ],
      "reason": "Two rollbacks: deployment_manager.rollback re-deploys an environment's previous release; model_registry.rollback archives a model's production version and restores the one before."
    },
    "spread": {
      "bound_to": [
        "function alphalab.macro.yield_curve.spread(curve: alphalab.macro.yield_curve.YieldCurve, short_tenor_years: decimal.Decimal, long_tenor_years: decimal.Decimal) -> decimal.Decimal | None",
        "function alphalab.market.book.spread(snapshot: alphalab.market.snapshot.OrderBookSnapshot) -> decimal.Decimal"
      ],
      "reason": "Two spreads: macro.spread is a yield curve's long-tenor minus short-tenor yield; market.spread is an order book's best ask minus best bid."
    },
    "surprise": {
      "bound_to": [
        "function alphalab.alt_data.information.surprise(event: 'InformationEvent', actual: 'str', expected: 'str') -> 'Decimal'",
        "function alphalab.macro.indicator.surprise(observation: alphalab.macro.indicator.IndicatorObservation) -> decimal.Decimal | None"
      ],
      "reason": "Two surprises: macro.surprise is an indicator's actual minus its recorded consensus; alt_data.surprise is the difference between two measurements an information event carries, which the caller names."
    },
    "validate_dataset": {
      "bound_to": [
        "function alphalab.api.validate_dataset(dataset: 'Dataset') -> 'tuple[ValidationFinding, ...]'",
        "function alphalab.backtesting.dataset.validate_dataset(dataset: 'MarketDataset') -> 'None'"
      ],
      "reason": "Two datasets, two checks, named by the argument: api.validate_dataset(Dataset) re-checks an ingested canonical dataset and returns every finding; backtesting.validate_dataset(MarketDataset) checks the market dataset a run consumes and raises on the first problem. The argument types differ, so passing one to the other fails type checking."
    }
  }
}