"""
PIT Keywords - Auto-Generated (UNIFIED)
========================================
Generated on: 2026-02-02 21:42:45
Total keywords: 185
Mode: Full

DO NOT EDIT THIS FILE MANUALLY!
Regenerate using: python generate_pit_keywords.py 

SINGLE SOURCE OF TRUTH
======================
This module provides two mixin classes generated from the SAME source:

1. PITKeywordsMixin - @staticmethod methods for F class
   Usage: F.eq_spot('SX5E')

2. InputKeywordsMixin - instance methods with 'name' param for InputBuilder
   Usage: builder.add_input.eq_spot('MySpot', 'SX5E')

Both are generated from pit_keywords.json ensuring consistency.

ENUM SUPPORT
============
Parameters that accept PIT constants use Python Enums for IDE autocomplete:
- Calendar, DayCount, Frequency, DateRule, Stub, ResetTiming, PayTiming, RfrLagType

Note: Additional enum values can be extracted from PIT C++ Lib if needed.
"""

from __future__ import annotations

from typing import TYPE_CHECKING, Union

if TYPE_CHECKING:
    from datetime import date

    from .pit_formula_base import FormulaExpression, FunctionCall
    from .pit_payoff import Payoff

# Runtime imports - from base module to avoid circular dependency
from .pit_enums import *
from .pit_formula_base import FunctionCall

# ============================================================
# PITKeywordsMixin - for F class (staticmethods)
# ============================================================


class PITKeywordsMixin:
    """
    Auto-generated PIT keyword methods for F class.

    All methods are @staticmethod returning FunctionCall.

    Example:
        spot = F.eq_spot('SX5E')  # Returns FunctionCall("EqSpot", "SX5E")
    """

    @staticmethod
    def if_(
        condition: Union[str, float, FormulaExpression],
        value_if_true: Union[str, float, FormulaExpression] = None,
        value_if_false: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        If - Conditional expression that evaluates a condition and returns different values based on the result.

        Python's 'if' is a reserved keyword, so we use 'if_' (PEP 8 trailing underscore convention).

        PIT Syntax: If( Condition, [Value If True], [Value If False] )

        Args:
            condition: Condition to evaluate for each path
            value_if_true: Value returned if Condition is true (optional)
            value_if_false: Value returned if Condition is false (optional)

        Returns:
            FunctionCall representing If(...)
        """
        args = []
        args.append(condition)
        if value_if_true is not None:
            args.append(value_if_true)
        if value_if_false is not None:
            args.append(value_if_false)
        return FunctionCall("If", *args)

    @staticmethod
    def max(a: Union[str, float, FormulaExpression], b: Union[str, float, FormulaExpression] = None) -> "FunctionCall":
        """
        Max - Returns the maximum of two numbers.

        PIT Syntax: Max( A, [B] )

        Args:
            a: First argument
            b: next arguments (optional)

        Returns:
            FunctionCall representing Max(...)
        """
        args = []
        args.append(a)
        if b is not None:
            args.append(b)
        return FunctionCall("Max", *args)

    @staticmethod
    def min(a: Union[str, float, FormulaExpression], b: Union[str, float, FormulaExpression] = None) -> "FunctionCall":
        """
        Min - Returns the minimum of two numbers.

        PIT Syntax: Min( A, [B] )

        Args:
            a: First argument
            b: next arguments (optional)

        Returns:
            FunctionCall representing Min(...)
        """
        args = []
        args.append(a)
        if b is not None:
            args.append(b)
        return FunctionCall("Min", *args)

    @staticmethod
    def as_of_date() -> "FunctionCall":
        """
        AsOfDate - This keyword returns the as of date of the product. In Price-it templates, the as of date is to be set in the 'Product description' sheet. It is almost always initialized to today's date but take any ...

        PIT Syntax: AsOfDate( )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing AsOfDate(...)
        """
        return FunctionCall("AsOfDate")

    @staticmethod
    def add_period(
        date: Union[str, date, FormulaExpression],
        maturity: Union[str, float, FormulaExpression],
        calendar: Union[Calendar, str] = "DEFAULT_PER_CURRENCY",
        adj_type: Union[DateRule, str] = "FOLLOWING",
    ) -> "FunctionCall":
        """
        AddPeriod - This keyword takes                           two input values: a date and a period (1d, 3m, 7y).                           Basically, it adds the pe...

        PIT Syntax: AddPeriod( date, maturity, [calendar], [adj type] )

        Args:
            date: date
            maturity: maturity
            calendar: calendar (optional)
            adj_type: adjustment type (optional)

        Returns:
            FunctionCall representing AddPeriod(...)
        """
        args = []
        args.append(date)
        args.append(maturity)
        if calendar is not None:
            args.append(calendar)
        if adj_type is not None:
            args.append(adj_type)
        return FunctionCall("AddPeriod", *args)

    @staticmethod
    def business_date(date: Union[str, date, FormulaExpression], calendar: Union[Calendar, str]) -> "FunctionCall":
        """
        BusinessDate: - This keyword takes 2 compulsory arguments : a date and a calendar. It returns the same date if the considered date is a business date. Otherwise, it returns the first business date following the consi...

        PIT Syntax: BusinessDate( date, calendar )

        Args:
            date: date
            calendar: calendar

        Returns:
            FunctionCall representing BusinessDate:(...)
        """
        return FunctionCall("BusinessDate:", date, calendar)

    @staticmethod
    def from_to(
        from_date_or_datetable, to_date=None, frequency=None, calendar=None, date_rule=None, date_inclusion_mode=None
    ):
        """
        FromTo - Creates periodic event dates for frequent observations. Supports two syntaxes.
        Must be used with ScheduleType.ALL_THE_TIME.

        Syntax 1 - Date Range:
            FromTo(From, To, [Frequency], [Calendar], [DateRule], [DateInclusionMode])
            Use when: You want to specify explicit start/end dates

        Syntax 2 - Using DateTable:
            FromTo(DateTable, [Frequency], [DateInclusionMode])
            Use when: You want automatic management of past/future events based on DateTable

        Args:
            from_date_or_datetable: Either a start date (Syntax 1) or a DateTable object (Syntax 2)
            to_date: End date (required for Syntax 1, must be None for Syntax 2)
            frequency: Observation frequency (optional). Default: 1D
                       - Syntax 1: Future observation frequency
                       - Syntax 2: Observation frequency for the entire period
            calendar: Observation calendar (optional, Syntax 1 only). Default: NoCalendar
            date_rule: Date adjustment rule (optional, Syntax 1 only). Default: UNADJUSTED
            date_inclusion_mode: Date inclusion mode (optional, both syntaxes)
                               BOTH | ONLYSTARTDATE | ONLYENDDATE | NONE. Default: BOTH

        Returns:
            FunctionCall representing FromTo(...)

        Examples:
            # Syntax 1: Date range
            F.from_to(start_date, end_date, frequency="1W")

            # Syntax 2: Using DateTable
            dt = F.date_table(start_date, end_date, Frequency=Frequency.DAILY)
            F.from_to(dt, frequency="1D")
        """
        # Detect which syntax based on presence of to_date
        if to_date is not None:
            # Syntax 1: FromTo(From, To, [Frequency], [Calendar], [DateRule], [DateInclusionMode])
            args = [from_date_or_datetable, to_date]
            if frequency is not None:
                args.append(frequency)
            if calendar is not None:
                args.append(calendar)
            if date_rule is not None:
                args.append(date_rule)
            if date_inclusion_mode is not None:
                args.append(date_inclusion_mode)
            return FunctionCall("FromTo", *args)
        else:
            # Syntax 2: FromTo(DateTable, [Frequency], [DateInclusionMode])
            args = [from_date_or_datetable]
            if frequency is not None:
                args.append(frequency)
            if date_inclusion_mode is not None:
                args.append(date_inclusion_mode)
            return FunctionCall("FromTo", *args)

    @staticmethod
    def current_date() -> "FunctionCall":
        """
        CurrentDate - This keyword returns the date associated to the current cashflow. Please note that it is different from the as of date and today's date. For instance, in a ATDATE line, it returns the date specified i...

        PIT Syntax: CurrentDate( )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing CurrentDate(...)
        """
        return FunctionCall("CurrentDate")

    @staticmethod
    def dcf(
        from_: Union[str, date, FormulaExpression],
        to_: Union[str, date, FormulaExpression],
        day_count: Union[DayCount, str],
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        DCF - This keyword returns the day fraction between the dates given as arguments. A third argument, the day count fraction, may be added.

        PIT Syntax: DCF( From, To, Day Count, [Calendar] )

        Args:
            from_: From this date
            to_: To this date
            day_count: convention ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing DCF(...)
        """
        args = []
        args.append(from_)
        args.append(to_)
        args.append(day_count)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("DCF", *args)

    @staticmethod
    def date_table(
        start_date: Union[str, date, FormulaExpression],
        end_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str] = "SemiAnnual",
        daycount: Union[DayCount, str] = "Act/360",
        resetgap: Union[str, float, FormulaExpression] = "-2b",
        paygap: Union[str, float, FormulaExpression] = "0b",
        calendar: Union[Calendar, str] = "Target",
        arrear: Union[ResetTiming, str] = "No",
        stub: Union[Stub, str] = "ShortStart",
        adjusted: Union[DateRule, str] = "ModFollowing",
        payadvance: Union[str, float, FormulaExpression] = "No",
    ) -> "FunctionCall":
        """
        DateTable - This keyword returns a dateTable object.

        PIT Syntax: DateTable( Start Date, End Date, [Frequency], [DayCount], [ResetGap], [PayGap], [Calendar], [Arrear], [Stub], [Adjusted], [PayAdvance] )

        Args:
            start_date: start date
            end_date: start date
            frequency: Frequency (optional)
            daycount: Days Count convention ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)
            resetgap: reset gap : number of day for reset, something like -2b (corresponding tag ResetGap:= ) (optional)
            paygap: pay gap : number of day for pay gap, something like 0b (corresponding tag PayGap:= ) (optional)
            calendar: calendar name: something like TARGET (corresponding tag calendar:= ) (optional)
            arrear: Arrear flag: tells if in arrear something like [Y]es|[N]o (corresponding tag Arrear:= ) (optional)
            stub: Stub flag: something like ShortStart[SS]|LongStart[LS] (corresponding tag Stub:= ) (optional)
            adjusted: Adjusted flag: something like [Y]es|[N]o  (corresponding tag Adjusted:= ) (optional)
            payadvance: Pay in Advance flag: [Y]es|[N]o (corresponding tag PayAdvance:= ) (optional)

        Returns:
            FunctionCall representing DateTable(...)
        """
        args = []
        args.append(start_date)
        args.append(end_date)
        if frequency is not None:
            args.append(frequency)
        if daycount is not None:
            args.append(daycount)
        if resetgap is not None:
            args.append(resetgap)
        if paygap is not None:
            args.append(paygap)
        if calendar is not None:
            args.append(calendar)
        if arrear is not None:
            args.append(arrear)
        if stub is not None:
            args.append(stub)
        if adjusted is not None:
            args.append(adjusted)
        if payadvance is not None:
            args.append(payadvance)
        return FunctionCall("DateTable", *args)

    @staticmethod
    def reset_date() -> "FunctionCall":
        """
        ResetDate - This keyword works only with a deterministic time schedule and indicates the reset date with respect        to the current period of the schedule. The ScheduleType can be: AtDate or OnSchedul...

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing ResetDate(...)
        """
        return FunctionCall("ResetDate")

    @staticmethod
    def pay_date() -> "FunctionCall":
        """
        PayDate - This keyword works only with a deterministic time schedule and indicates the payment date with respect        to the current period of the schedule. The ScheduleType can be: AtDate or OnSched...

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing PayDate(...)
        """
        return FunctionCall("PayDate")

    @staticmethod
    def period_start() -> "FunctionCall":
        """
        PeriodStart - This keyword works only with a deterministic time schedule and indicates the start date with respect        to the current period of the schedule. The ScheduleType can be: AtDate or OnSchedul...

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing PeriodStart(...)
        """
        return FunctionCall("PeriodStart")

    @staticmethod
    def period_end() -> "FunctionCall":
        """
        PeriodEnd - This keyword works only with a deterministic time schedule and indicates the end date with respect        to the current period of the schedule. The ScheduleType can be: AtDate or OnSchedule ...

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing PeriodEnd(...)
        """
        return FunctionCall("PeriodEnd")

    @staticmethod
    def event_date() -> "FunctionCall":
        """
        EventDate - This keyword works only with a deterministic time schedule and indicates the event date with respect        to the current period of the schedule. The ScheduleType can be: AtDate or OnSchedul...

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing EventDate(...)
        """
        return FunctionCall("EventDate")

    @staticmethod
    def accrual_value() -> "FunctionCall":
        """
        AccrualValue -

        PIT Syntax: AccrualValue( Coupon of the Accrual, [Maturity], [Calendar], [Date rule], [DayCount] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing AccrualValue(...)
        """
        return FunctionCall("AccrualValue")

    @staticmethod
    def assign(
        value_to_assign: Union[str, float, FormulaExpression],
        value_in_the_past: Union[str, float, FormulaExpression] = "0",
    ) -> "FunctionCall":
        """
        Assign - The keyword Assign()  enables to assign a value to a column. It means that current cell is filled with the input value and all others are set to 0. It may be useful when describing a product which c...

        PIT Syntax: Assign( value to assign, [value in the past] )

        Args:
            value_to_assign: value to assign
            value_in_the_past: value taken when evaluating assing in the past? (optional)

        Returns:
            FunctionCall representing Assign(...)
        """
        args = []
        args.append(value_to_assign)
        if value_in_the_past is not None:
            args.append(value_in_the_past)
        return FunctionCall("Assign", *args)

    @staticmethod
    def column_val(column_name: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        ColumnVal - This keyword takes only one argument, which is the name of the column. However, if we want to describe an American style product or a path dependant product, one has to add respectively a NextVal and ...

        PIT Syntax: ColumnVal( column name )

        Args:
            column_name: name of the column

        Returns:
            FunctionCall representing ColumnVal(...)
        """
        return FunctionCall("ColumnVal", column_name)

    @staticmethod
    def df(
        currency: Union[str, float, FormulaExpression], tenor_or_end_date: Union[str, date, FormulaExpression]
    ) -> "FunctionCall":
        """
        DF - The discount factor takes two arguments : (1) the name of the Interest Rate Model to compute the discount factor with and (2) a tenor. The tenor has to be an Excel date plus a certain number of days/m...

        PIT Syntax: DF( Currency, Tenor or End Date )

        Args:
            currency: Name of the currency index.                                                                                 When used with a multi asset model, the user should provide for this currency name an                                                                                 interest rates model in the multi asset model name map
            tenor_or_end_date: Tenor or End Date of the discount Factor,                                                                                  a tenor is nb followed by d/w/m/y like 6m or 1y

        Returns:
            FunctionCall representing DF(...)
        """
        return FunctionCall("DF", currency, tenor_or_end_date)

    @staticmethod
    def discount_factor(
        currency: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        curve_index: Union[str, float, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        Discount factor - The discount factor takes three arguments : (1) the name of the Interest Rate Model to compute the discount factor from a start date (2) to an end date or a tenor (3) The tenor has to be an Excel date...

        PIT Syntax: DiscountFactor( Currency, StartDate, Tenor or End Date, [Curve Index] )

        Args:
            currency: Name of the currency index.                                                                                 When used with a multi asset model, the user should provide for this currency name an                                                                                 interest rates model in the multi asset model name map
            startdate: Start date of the discount Factor
            tenor_or_end_date: Tenor or End Date of the discount Factor,                                                                                  a tenor is nb followed by d/w/m/y like 6m or 1y
            curve_index: DISCOUNTING for the default discount curve. 1M, 3M, 6M (optional)

        Returns:
            FunctionCall representing Discount factor(...)
        """
        args = []
        args.append(currency)
        args.append(startdate)
        args.append(tenor_or_end_date)
        if curve_index is not None:
            args.append(curve_index)
        return FunctionCall("Discount factor", *args)

    @staticmethod
    def e(expression: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        E - This keyword takes into argument the reference to a future cashflow and returns its expectation. No discounting between current date and the cashflow date is done ! However, if it is a priced column, ...

        PIT Syntax: E( expression )

        Args:
            expression: Expression to be used for the expectation

        Returns:
            FunctionCall representing E(...)
        """
        return FunctionCall("E", expression)

    @staticmethod
    def exercise(
        option_payoff_h: Union[str, float, FormulaExpression],
        continuation_payoff_c: Union[str, float, FormulaExpression],
        holder_of_the_option: Union[str, float, FormulaExpression] = "Us",
        past_exercise_decision: Union[str, float, FormulaExpression] = "1",
        regression_variables: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        Exercise - Suppose that you hold a financial product and that, at an event date, you have the        right to do the following:  (1) either (to exercise the product and) to receive the payoff H,  (2) ei...

        PIT Syntax: Exercise( Option payoff H, Continuation payoff C, [Holder of the option], [Past exercise decision], [Regression Variables] )

        Args:
            option_payoff_h: exercise Payoff
            continuation_payoff_c: Continuation Payoff
            holder_of_the_option: Tells if the buyer or seller hold the exercise option (optional)
            past_exercise_decision: Has the option been exercised (only in the past) (optional)
            regression_variables: Regression Variables (optional)

        Returns:
            FunctionCall representing Exercise(...)
        """
        args = []
        args.append(option_payoff_h)
        args.append(continuation_payoff_c)
        if holder_of_the_option is not None:
            args.append(holder_of_the_option)
        if past_exercise_decision is not None:
            args.append(past_exercise_decision)
        if regression_variables is not None:
            args.append(regression_variables)
        return FunctionCall("Exercise", *args)

    @staticmethod
    def fwd_val(
        payoff_to_fwdval: Union[str, float, FormulaExpression],
        deterministic_discounting: Union[str, float, FormulaExpression] = "DETERMINISTIC",
    ) -> "FunctionCall":
        """
        FwdVal - This keyword takes into argument the reference to a future cashflow and returns its expectation. No discounting between current date and the cashflow date is done. Moroever, it prevents discouting the...

        PIT Syntax: FwdVal( Payoff to FwdVal, [Deterministic Discounting?] )

        Args:
            payoff_to_fwdval: Cancels the discounting on the payoff
            deterministic_discounting: Deterministic, otherwise Stochastic discounting (optional)

        Returns:
            FunctionCall representing FwdVal(...)
        """
        args = []
        args.append(payoff_to_fwdval)
        if deterministic_discounting is not None:
            args.append(deterministic_discounting)
        return FunctionCall("FwdVal", *args)

    @staticmethod
    def get_value(
        dictionary_model: Union[str, float, FormulaExpression], dictionary_key: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        GetValue - Get value in dictionary

        PIT Syntax: GetValue( Dictionary model, Dictionary key )

        Args:
            dictionary_model: Dictionary model name
            dictionary_key: Dictionary key

        Returns:
            FunctionCall representing GetValue(...)
        """
        return FunctionCall("GetValue", dictionary_model, dictionary_key)

    @staticmethod
    def model_factor(model_factor_rank: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        ModelFactor - This keyword takes in parameter an integer n and returns the value of the                           (n+1)th model factor. For instance, on a Hull-White 2 factor model, one  ...

        PIT Syntax: ModelFactor( Model factor rank )

        Args:
            model_factor_rank: Refers to a model factor

        Returns:
            FunctionCall representing ModelFactor(...)
        """
        return FunctionCall("ModelFactor", model_factor_rank)

    @staticmethod
    def pay(
        payment_date: Union[str, date, FormulaExpression], payment_flow: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        Pay - This keyword has a singular syntax for it should be placed at the beginning of an expression, without any braces. Basically, it multiplies the expression by -DF(event,pay).This keyword takes into argu...

        PIT Syntax: Pay( Payment date, Payment flow )

        Args:
            payment_date: Maturity or Payment Date
            payment_flow: Payment flow

        Returns:
            FunctionCall representing Pay(...)
        """
        return FunctionCall("Pay", payment_date, payment_flow, _braceless=True)

    @staticmethod
    def pv(future_payoff: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        PV - This keyword takes into argument the reference to a future cashflow and returns its present value. It performs the discounting between current date and the cashflow date. If it is a priced column, dis...

        PIT Syntax: PV( Future Payoff )

        Args:
            future_payoff: Reference to a Deal Description Cell

        Returns:
            FunctionCall representing PV(...)
        """
        return FunctionCall("PV", future_payoff)

    @staticmethod
    def receive(
        payment_date: Union[str, date, FormulaExpression], payment_flow: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        Receive - This keyword has a singular syntax for it should be placed at the beginning of an expression, without any braces. Basically, it multiplies the expression by DF(event,pay).This keyword takes into argum...

        PIT Syntax: Receive( Payment date, Payment flow )

        Args:
            payment_date: Maturity or Payment Date
            payment_flow: Payment flow

        Returns:
            FunctionCall representing Receive(...)
        """
        return FunctionCall("Receive", payment_date, payment_flow, _braceless=True)

    @staticmethod
    def trigger(
        expression_to_evaluate: Union[str, float, FormulaExpression],
        expression_if_true: Union[str, float, FormulaExpression],
        expression_if_false: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        Trigger - Trigger() keyword is similar to the if keyword.  (1) Trigger evaluates an expression and returns the true or false condition depending on the expression.  (2) The difference between if and Trigger i...

        PIT Syntax: Trigger( Expression to Evaluate, Expression if true, Expression if false )

        Args:
            expression_to_evaluate: Expression to evaluate.
            expression_if_true: Expression if the comparison is true
            expression_if_false: Expression if the comparison is false.

        Returns:
            FunctionCall representing Trigger(...)
        """
        return FunctionCall("Trigger", expression_to_evaluate, expression_if_true, expression_if_false)

    @staticmethod
    def get_ir_mkt_vol(
        model: Union[str, float, FormulaExpression],
        maturity_in_year_fraction: Union[str, float, FormulaExpression],
        tenor: Union[str, float, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        voltype: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        GetIRMktVol - Compute IR volatility from market data

        PIT Syntax: GetIRMktVol( Model, Maturity in year fraction, Tenor, Strike, VolType )

        Args:
            model: The model to compute the volatility
            maturity_in_year_fraction: Maturity in year fraction
            tenor: Tenor
            strike: Strike
            voltype: Swaption or Cap volatilities

        Returns:
            FunctionCall representing GetIRMktVol(...)
        """
        return FunctionCall("GetIRMktVol", model, maturity_in_year_fraction, tenor, strike, voltype)

    @staticmethod
    def formula_value(
        probabilitylaw: Union[str, float, FormulaExpression],
        formulaname: Union[str, float, FormulaExpression],
        parameters: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        FormulaValue - Value of an Analytical Formula

        PIT Syntax: FormulaValue( ProbabilityLaw, FormulaName, Parameters )

        Args:
            probabilitylaw: Underlying Probability Law
            formulaname: Name of the Formula
            parameters: Parameters of the Formula

        Returns:
            FunctionCall representing FormulaValue(...)
        """
        return FunctionCall("FormulaValue", probabilitylaw, formulaname, parameters)

    @staticmethod
    def callable_by() -> "FunctionCall":
        """
        CallableBy -

        PIT Syntax: CallableBy( Holder of the option, Option payoff H, [Regression Variables] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing CallableBy(...)
        """
        return FunctionCall("CallableBy")

    @staticmethod
    def abs(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Abs - Returns the absolute value. Same as Excel ABS(number).

        PIT Syntax: Abs( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Abs(...)
        """
        return FunctionCall("Abs", x)

    @staticmethod
    def and_(
        condition1: Union[str, float, FormulaExpression],
        condition2: Union[str, float, FormulaExpression],
        *additional_conditions: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        And - Logical AND operator (infix operator)

        Python's 'and' is a reserved keyword, so we use 'and_' (PEP 8 trailing underscore convention).

        PIT Syntax: condition1 && condition2 && ...

        Args:
            condition1: First logical condition
            condition2: Second logical condition
            *additional_conditions: Optional additional conditions to AND together

        Returns:
            FunctionCall representing condition1 && condition2 && ...
        """
        return FunctionCall("&&", condition1, condition2, *additional_conditions, _infix=True)

    @staticmethod
    def a_tan(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        ATan - Computes arctangent, or inverse tangent of x where x is a double.

        PIT Syntax: ATan( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing ATan(...)
        """
        return FunctionCall("ATan", x)

    @staticmethod
    def average(
        ref_range: Union[str, float, FormulaExpression], skipemptyrows: Union[str, float, FormulaExpression] = "False"
    ) -> "FunctionCall":
        """
        Average - Computes the arithmetic average of a range of numbers.

        PIT Syntax: Average( Ref Range, [SkipEmptyRows] )

        Args:
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)
            skipemptyrows: flag which specifies whether to take into account empty rows or 0 values in the computation (optional)

        Returns:
            FunctionCall representing Average(...)
        """
        args = []
        args.append(ref_range)
        if skipemptyrows is not None:
            args.append(skipemptyrows)
        return FunctionCall("Average", *args)

    @staticmethod
    def correl(
        array_1: Union[str, float, FormulaExpression],
        array_2: Union[str, float, FormulaExpression] = "EMPTY_RANGE",
        correlation_type: Union[str, float, FormulaExpression] = "LOG",
    ) -> "FunctionCall":
        """
        Correl - Computes the correlation

        PIT Syntax: Correl( Array 1, [Array 2 ], [Correlation type] )

        Args:
            array_1: Range of values (for instance AA[1]:ZZ[20] where AA and ZZ are column names)
            array_2: Range of values (for instance AA[1]:ZZ[20] where AA and ZZ are column names) (optional)
            correlation_type: Return or Log (optional)

        Returns:
            FunctionCall representing Correl(...)
        """
        args = []
        args.append(array_1)
        if array_2 is not None:
            args.append(array_2)
        if correlation_type is not None:
            args.append(correlation_type)
        return FunctionCall("Correl", *args)

    @staticmethod
    def cos(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Cos - Computes cosine of x where x is a double.

        PIT Syntax: Cos( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Cos(...)
        """
        return FunctionCall("Cos", x)

    @staticmethod
    def cum_norm(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        CumNorm - Computes an approximated value of the cumulative normal.

        PIT Syntax: CumNorm( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing CumNorm(...)
        """
        return FunctionCall("CumNorm", x)

    @staticmethod
    def exp(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Exp - Computes exponential(x) where x is a double.

        PIT Syntax: Exp( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Exp(...)
        """
        return FunctionCall("Exp", x)

    @staticmethod
    def interpol(
        curvename: Union[str, float, FormulaExpression], expression: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        Interpol - Interpolates a curve using the interpolation method that been                             associated to the curve at its creation.

        PIT Syntax: Interpol( curveName, expression )

        Args:
            curvename: CurveName
            expression: interpolation date

        Returns:
            FunctionCall representing Interpol(...)
        """
        return FunctionCall("Interpol", curvename, expression)

    @staticmethod
    def log(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Log - Computes the Neperian Logarithm

        PIT Syntax: Log( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Log(...)
        """
        return FunctionCall("Log", x)

    @staticmethod
    def or_(
        condition1: Union[str, float, FormulaExpression],
        condition2: Union[str, float, FormulaExpression],
        *additional_conditions: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        Or - Logical OR operator (infix operator)

        Python's 'or' is a reserved keyword, so we use 'or_' (PEP 8 trailing underscore convention).

        PIT Syntax: condition1 || condition2 || ...

        Args:
            condition1: First logical condition
            condition2: Second logical condition
            *additional_conditions: Optional additional conditions to OR together

        Returns:
            FunctionCall representing condition1 || condition2 || ...
        """
        return FunctionCall("||", condition1, condition2, *additional_conditions, _infix=True)

    @staticmethod
    def pow(a: Union[str, float, FormulaExpression], b: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Pow - Pow(a, b) returns the value of a to the power b.

        PIT Syntax: Pow( a, b )

        Args:
            a: Base
            b: Exponent

        Returns:
            FunctionCall representing Pow(...)
        """
        return FunctionCall("Pow", a, b)

    @staticmethod
    def modulo(x: Union[str, float, FormulaExpression], y: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Modulo - \input{language/modulo.tex}

        PIT Syntax: Modulo( x, y )

        Args:
            x: Dividend
            y: Divisor

        Returns:
            FunctionCall representing Modulo(...)
        """
        return FunctionCall("Modulo", x, y)

    @staticmethod
    def round(
        nb: Union[str, float, FormulaExpression],
        s: Union[str, float, FormulaExpression],
        t: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        Round - This function rounds a number. The Third argument specifies whether it rounds up, down or to the nearest integer. By default, it rounds down (like the mathematical integer function). Rounds does the r...

        PIT Syntax: Round( nb, s, [t] )

        Args:
            nb: number to round
            s: significance
            t: type (optional)

        Returns:
            FunctionCall representing Round(...)
        """
        args = []
        args.append(nb)
        args.append(s)
        if t is not None:
            args.append(t)
        return FunctionCall("Round", *args)

    @staticmethod
    def sin(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Sin - Computes sine of x where x is a double.

        PIT Syntax: Sin( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Sin(...)
        """
        return FunctionCall("Sin", x)

    @staticmethod
    def sqrt(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Sqrt - Returns the square root of a number. Returns -1.QNAN if the input is a                             negative number.

        PIT Syntax: Sqrt( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Sqrt(...)
        """
        return FunctionCall("Sqrt", x)

    @staticmethod
    def sum(ref_range: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Sum - Computes the sum of a range of numbers

        PIT Syntax: Sum( Ref Range )

        Args:
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)

        Returns:
            FunctionCall representing Sum(...)
        """
        return FunctionCall("Sum", ref_range)

    @staticmethod
    def product(ref_range: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Product - Computes the product of a range of numbers

        PIT Syntax: Product( Ref Range )

        Args:
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)

        Returns:
            FunctionCall representing Product(...)
        """
        return FunctionCall("Product", ref_range)

    @staticmethod
    def sum_product(
        ref_range: Union[str, float, FormulaExpression], ref_range_2: Union[str, float, FormulaExpression] = "1"
    ) -> "FunctionCall":
        """
        SumProduct - This keyword has a similar behaviour to that of Excel's SumProduct. It takes two arguments which can be either a double, a vector or a range. The second argument is optional and is equal to 1 by defau...

        PIT Syntax: SumProduct( Ref Range, [Ref Range] )

        Args:
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)
            ref_range_2: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names) (optional)

        Returns:
            FunctionCall representing SumProduct(...)
        """
        args = []
        args.append(ref_range)
        if ref_range_2 is not None:
            args.append(ref_range_2)
        return FunctionCall("SumProduct", *args)

    @staticmethod
    def tan(x: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Tan - Computes tangent of x where x is a double.

        PIT Syntax: Tan( x )

        Args:
            x: Operand

        Returns:
            FunctionCall representing Tan(...)
        """
        return FunctionCall("Tan", x)

    @staticmethod
    def next_val(value: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        NextVal - Next value (just indicative). NextVal(CF) DOES NOT MEAN CF[t+1].                           It simply indicates to the pricer that the product is American style.

        PIT Syntax: NextVal( value )

        Args:
            value: Value

        Returns:
            FunctionCall representing NextVal(...)
        """
        return FunctionCall("NextVal", value)

    @staticmethod
    def previous_val(value: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        PreviousVal - Previous value (just indicative). PreviousVal(CF) DOES NOT MEAN CF[t-1].                           It simply indicates to the pricer that the product is path dependent.

        PIT Syntax: PreviousVal( value )

        Args:
            value: Value

        Returns:
            FunctionCall representing PreviousVal(...)
        """
        return FunctionCall("PreviousVal", value)

    @staticmethod
    def report(value: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Report - Keyword to do reporting when everything has been computed.

        PIT Syntax: Report( value )

        Args:
            value: Value

        Returns:
            FunctionCall representing Report(...)
        """
        return FunctionCall("Report", value)

    @staticmethod
    def repeat() -> "FunctionCall":
        """
        Repeat -

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Repeat(...)
        """
        return FunctionCall("Repeat")

    @staticmethod
    def get_elem(
        index: Union[str, float, FormulaExpression], vector_of_vector: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        GetElem - Returns the nth element of a vector of vectors. Vectors of vectors are                             typically returned by Sort and PartialSort keywords.

        PIT Syntax: GetElem( index, vector of vector )

        Args:
            index: index of the element
            vector_of_vector: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)

        Returns:
            FunctionCall representing GetElem(...)
        """
        return FunctionCall("GetElem", index, vector_of_vector)

    @staticmethod
    def get_elems(
        start: Union[str, float, FormulaExpression],
        end: Union[str, float, FormulaExpression],
        vector_of_vector: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        GetElems - Returns subset of a vector of vectors. Vectors of vectors are                             typically returned by Sort and PartialSort keywords.

        PIT Syntax: GetElems( start, end, vector of vector )

        Args:
            start: index of the start element
            end: index of the end element
            vector_of_vector: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)

        Returns:
            FunctionCall representing GetElems(...)
        """
        return FunctionCall("GetElems", start, end, vector_of_vector)

    @staticmethod
    def nth() -> "FunctionCall":
        """
        Nth - This function takes an index n and a range as inputs. It sorts the range (in increasing order) and returns the n-th element. It can be viewed as an extended version of MIN and MAX keywords.

        PIT Syntax:

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Nth(...)
        """
        return FunctionCall("Nth")

    @staticmethod
    def partial_sort(
        index: Union[str, float, FormulaExpression], ref_range: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        PartialSort - The PartialSort keyword does a partial sort of a range up to a                             specified order and returns the sorted range. You have then to use        ...

        PIT Syntax: PartialSort( index, Ref Range )

        Args:
            index: index of the element
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)

        Returns:
            FunctionCall representing PartialSort(...)
        """
        return FunctionCall("PartialSort", index, ref_range)

    @staticmethod
    def partial_sort_with_options(
        index: Union[str, float, FormulaExpression],
        ref_range: Union[str, float, FormulaExpression],
        sorting_order: Union[str, float, FormulaExpression] = "Ascending",
    ) -> "FunctionCall":
        """
        PartialSortWithOptions - The PartialSortWithOptions keyword does a partial sort of a range up to                             a specified order and returns the sorted range (sorted in ascending or ...

        PIT Syntax: PartialSortWithOptions( [Sorting Order], index, Ref Range )

        Args:
            index: index of the element
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)
            sorting_order: Sorting order: ascending(default) or descending (optional)

        Returns:
            FunctionCall representing PartialSortWithOptions(...)
        """
        args = []
        if sorting_order is not None:
            args.append(sorting_order)
        args.append(index)
        args.append(ref_range)
        return FunctionCall("PartialSortWithOptions", *args)

    @staticmethod
    def rank__deprecated() -> "FunctionCall":
        """
        Rank: Deprecated -

        PIT Syntax: Rank( index, Ref Range )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Rank: Deprecated(...)
        """
        return FunctionCall("Rank: Deprecated")

    @staticmethod
    def sort(ref_range: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Sort - The Sort keyword sorts a range and returns the sorted range. You                             should then use GetElem to retrieve the corresponding element. If you     ...

        PIT Syntax: Sort( Ref Range )

        Args:
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)

        Returns:
            FunctionCall representing Sort(...)
        """
        return FunctionCall("Sort", ref_range)

    @staticmethod
    def sort_with_options(
        ref_range: Union[str, float, FormulaExpression],
        sorting_order: Union[str, float, FormulaExpression] = "Ascending",
    ) -> "FunctionCall":
        """
        SortWithOptions - The SortWithOptions keyword sorts a range and returns the sorted                             range (sorted in ascending or descending order). You should then use      ...

        PIT Syntax: SortWithOptions( [Sorting Order], Ref Range )

        Args:
            ref_range: Range of references (for instance AA[1]:ZZ[20] where AA and ZZ are column names)
            sorting_order: Sorting order: ascending(default) or descending (optional)

        Returns:
            FunctionCall representing SortWithOptions(...)
        """
        args = []
        if sorting_order is not None:
            args.append(sorting_order)
        args.append(ref_range)
        return FunctionCall("SortWithOptions", *args)

    @staticmethod
    def commo_spot(
        model: Union[str, float, FormulaExpression],
        fixing_type: Union[str, float, FormulaExpression] = None,
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        CommoSpot - Commodity Spot

        PIT Syntax: CommoSpot( Model , [Fixing type ], [Settlement Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            fixing_type: Fixing type (either CLOSE, HIGH, LOW, etc..) (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)

        Returns:
            FunctionCall representing CommoSpot(...)
        """
        args = []
        args.append(model)
        if fixing_type is not None:
            args.append(fixing_type)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        return FunctionCall("CommoSpot", *args)

    @staticmethod
    def commo_fwd(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        CommoFwd - Commodity Forward

        PIT Syntax: CommoFwd( Model , Expiry Date , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry date of the forward
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing CommoFwd(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("CommoFwd", *args)

    @staticmethod
    def commo_call(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        CommoCall - Prices a call/put on a commodity underlying. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If...

        PIT Syntax: CommoCall( Model , Expiry Date , Strike , Call/Put , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing CommoCall(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("CommoCall", *args)

    @staticmethod
    def commo_digital(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression] = "1",
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        CommoDigital - Prices a digital option on a commodity underlying. A digital call pays 1 if the spot is higher that the strike and 0 otherwise. The price of the contract is computed in closed form by the used model. ...

        PIT Syntax: CommoDigital( Model , Expiry Date , Strike , Call/Put , [Notional ], [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the forward
            strike: Call strike in real terms
            call_put: Option's type CALL or PUT (Digital Case)
            notional: Notional of the digital (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing CommoDigital(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        if notional is not None:
            args.append(notional)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("CommoDigital", *args)

    @staticmethod
    def commo_calendar_spread(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        first_future_date: Union[str, date, FormulaExpression],
        second_future_date: Union[str, date, FormulaExpression],
        usedcorrel: Union[str, float, FormulaExpression] = "-2",
    ) -> "FunctionCall":
        """
        CommoCalendarSpread - This keyword computes the price of commo spread option on 2 futures of the same underlying

        PIT Syntax: CommoCalendarSpread( Model , Expiry Date , Strike , Call/Put , First Future Date , Second Future Date , [UsedCorrel ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            first_future_date: First Future Date of the spread option
            second_future_date: Second Future Date of the spread option
            usedcorrel: Correlation given by user (optional)

        Returns:
            FunctionCall representing CommoCalendarSpread(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(first_future_date)
        args.append(second_future_date)
        if usedcorrel is not None:
            args.append(usedcorrel)
        return FunctionCall("CommoCalendarSpread", *args)

    @staticmethod
    def commo_histo_vol(
        model: Union[str, float, FormulaExpression], histo_maturity: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        CommoHistoVol - Commodity historical volatility

        PIT Syntax: CommoHistoVol( Model , histo maturity )

        Args:
            model: The model to compute the spot value with
            histo_maturity: Maturity for the histo vol

        Returns:
            FunctionCall representing CommoHistoVol(...)
        """
        return FunctionCall("CommoHistoVol", model, histo_maturity)

    @staticmethod
    def commo_bs_vol(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        CommoBSVol - Returns the corresponding Black Scholes volatility for a given call or put on an Commo. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scho...

        PIT Syntax: CommoBSVol( Model , Expiry Date , Strike , Call/Put , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing CommoBSVol(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("CommoBSVol", *args)

    @staticmethod
    def commo_var_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        CommoVarSwap - Commodity variance Swap

        PIT Syntax: CommoVarSwap( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance swap strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing CommoVarSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("CommoVarSwap", *args)

    @staticmethod
    def commo_vol_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        CommoVolSwap - Commodity volatility Swap

        PIT Syntax: CommoVolSwap( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Volatility swap strike
            notional: Notional
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing CommoVolSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("CommoVolSwap", *args)

    @staticmethod
    def commo_var_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        CommoVarOption - Commodity variance call

        PIT Syntax: CommoVarOption( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Implied Volatility ], [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance option strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            implied_volatility: Market Implied Volatility (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing CommoVarOption(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("CommoVarOption", *args)

    @staticmethod
    def commo_vol_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        CommoVolOption - Commodity volatility call

        PIT Syntax: CommoVolOption( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Implied Volatility ], [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Volatility option strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            implied_volatility: Market Implied Volatility (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing CommoVolOption(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("CommoVolOption", *args)

    @staticmethod
    def commo_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        rebate: Union[str, float, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        CommoBarrier - Prices analytically a classical barrier option on the future of a commodity with the same maturity. The barrier can be monitored continuously or discretely between the start date and end date. Actuall...

        PIT Syntax: CommoBarrier( Model , Expiry Date , Strike , Call/Put , Barrier , Barrier Type , [StartDate ], [EndDate ], [Rebate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            rebate: Rebate (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing CommoBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(barrier)
        args.append(barrier_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if rebate is not None:
            args.append(rebate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("CommoBarrier", *args)

    @staticmethod
    def commo_double_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        lowbarrier: Union[str, float, FormulaExpression],
        upbarrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        CommoDoubleBarrier - Prices analytically a double barrier option on the future of a commodity with the same maturity. The barriers can be monitored continuously or discretely between the start date and end date. Actually,...

        PIT Syntax: CommoDoubleBarrier( Model , Expiry Date , Strike , Call/Put , LowBarrier , UpBarrier , Barrier Type , [StartDate ], [EndDate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            lowbarrier: Lower Barrier level
            upbarrier: Upper Barrier level
            barrier_type: Barrier's type KNOCKIN or KNOCKOUT
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing CommoDoubleBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(lowbarrier)
        args.append(upbarrier)
        args.append(barrier_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("CommoDoubleBarrier", *args)

    @staticmethod
    def commo_digital_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        payoff_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        CommoDigitalBarrier - Prices analytically a digital barrier option on the future of a commodity with the same maturity. The barrier can be monitored continuously or discretely between the start date and end date. Actually,...

        PIT Syntax: CommoDigitalBarrier( Model , Expiry Date , Strike , Call/Put , Barrier , Barrier Type , Payoff Type , [StartDate ], [EndDate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            payoff_type: Barrier's type CASH or ASSET
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing CommoDigitalBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(barrier)
        args.append(barrier_type)
        args.append(payoff_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("CommoDigitalBarrier", *args)

    @staticmethod
    def commo_shifted_barrier(
        model: Union[str, float, FormulaExpression],
        spot: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        frequency: Union[Frequency, str] = "Daily",
        currentdate: Union[str, date, FormulaExpression] = "0",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        CommoShiftedBarrier - This keyword computes the adjusted stochastic barrier at which the discrete barrier option price matches with the continuous monitoring one at initial barrier level

        PIT Syntax: CommoShiftedBarrier( Model , Spot , Barrier , Barrier Type , [Frequency ], [CurrentDate ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            spot: Current Spot level
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            frequency: Frequency of discrete barrier  1D, 2D, 3D, 4D, 5D, W,... (optional)
            currentdate: Current Date for barrier monitoring (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing CommoShiftedBarrier(...)
        """
        args = []
        args.append(model)
        args.append(spot)
        args.append(barrier)
        args.append(barrier_type)
        if frequency is not None:
            args.append(frequency)
        if currentdate is not None:
            args.append(currentdate)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("CommoShiftedBarrier", *args)

    @staticmethod
    def commo_asian(
        model: Union[str, float, FormulaExpression],
        expiry_option_date: Union[str, date, FormulaExpression],
        expiry_future_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        method: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        CommoAsian - The keyword prices analytically a classical Asian option on the future of a commodity with the same maturity The Option can be monitored Daily, weekly or Monthly. One of the following methods should b...

        PIT Syntax: CommoAsianOption( Model , Expiry Option Date , Expiry Future Date , Strike , Call/Put , Method , StartDate , EndDate , Frequency , [Calendar ] )

        Args:
            model: The model to compute the spot value with
            expiry_option_date: Expiry Date of the option
            expiry_future_date: Expiry Date of the future
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            method: Method : Curran, Ju or Sophis
            startdate: Start Date for Asian monitoring
            enddate: End Date for Asian monitoring
            frequency: Asian's Frequency 1D, 2D, 3D, 4D, 5D, W,...
            calendar: Asian's Calendar (optional)

        Returns:
            FunctionCall representing CommoAsian(...)
        """
        args = []
        args.append(model)
        args.append(expiry_option_date)
        args.append(expiry_future_date)
        args.append(strike)
        args.append(call_put)
        args.append(method)
        args.append(startdate)
        args.append(enddate)
        args.append(frequency)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("CommoAsian", *args)

    @staticmethod
    def default_date(
        portfolioname: Union[str, float, FormulaExpression],
        uptothisdate: Union[str, date, FormulaExpression],
        fromthisdate: Union[str, date, FormulaExpression] = "AsOfDate",
    ) -> "FunctionCall":
        """
        DefaultDate - This keyword indicates default times occuring either with respect to single CDS or over a Credit portfolio. The default dates are considered between a start date and a end date, which are he last two ...

        PIT Syntax: DefaultDate( PortfolioName, [FromThisDate], UpToThisDate )

        Args:
            portfolioname: The name of a Credit instrument. It may be a CDS ticker or a Credit Portfolio name.
            uptothisdate: Default Max Date
            fromthisdate: Default Min Date (optional)

        Returns:
            FunctionCall representing DefaultDate(...)
        """
        args = []
        args.append(portfolioname)
        if fromthisdate is not None:
            args.append(fromthisdate)
        args.append(uptothisdate)
        return FunctionCall("DefaultDate", *args)

    @staticmethod
    def marginal_loss(
        portfolioname: Union[str, float, FormulaExpression], index_nb: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        MarginalLoss - Individual Loss

        PIT Syntax: MarginalLoss( PortfolioName, index nb )

        Args:
            portfolioname: The portfolio name
            index_nb: Index number

        Returns:
            FunctionCall representing MarginalLoss(...)
        """
        return FunctionCall("MarginalLoss", portfolioname, index_nb)

    @staticmethod
    def accrued_on_default(
        model: Union[str, float, FormulaExpression], datetable: Union[str, date, FormulaExpression]
    ) -> "FunctionCall":
        """
        AccruedOnDefault - This keyword computes the time lag between a default time and the previous date of a periodic schedule. The default date is the default date of a single CDS or of a CDS belonging to a Portfolio. The c...

        PIT Syntax: AccruedOnDefault( Model, DateTable )

        Args:
            model: The name of a Credit instrument. It may be a CDS ticker or a Credit Portfolio name.
            datetable: DateTable object to define the schedule.

        Returns:
            FunctionCall representing AccruedOnDefault(...)
        """
        return FunctionCall("AccruedOnDefault", model, datetable)

    @staticmethod
    def accrued(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        end_date: Union[str, date, FormulaExpression],
        calendar: Union[Calendar, str] = "DEFAULT_PER_CURRENCY",
        freq_period: Union[Frequency, str] = "DEFAULT_PER_CURRENCY",
        daycount: Union[DayCount, str] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        Accrued - This keyword computes the time lag between a default time and the previous date of a periodic schedule. The default date is the default date of a single CDS or of a CDS belonging to a Portfolio. The c...

        PIT Syntax: Accrued( Model, Start Date, End Date, [Calendar], [Freq Period], [DayCount] )

        Args:
            model: The name of a Credit instrument. It may be a CDS ticker or a Credit Portfolio name.
            start_date: CDS Start date
            end_date: CDS Start date
            calendar: Calendar (optional)
            freq_period: Frequency (optional)
            daycount: DayCount (optional)

        Returns:
            FunctionCall representing Accrued(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(end_date)
        if calendar is not None:
            args.append(calendar)
        if freq_period is not None:
            args.append(freq_period)
        if daycount is not None:
            args.append(daycount)
        return FunctionCall("Accrued", *args)

    @staticmethod
    def basket_accrued_on_default(
        portfolioname: Union[str, float, FormulaExpression],
        schedule: Union[str, float, FormulaExpression],
        lowerattachmentpoint: Union[str, float, FormulaExpression],
        upperattachmentpoint: Union[str, float, FormulaExpression],
        recovery: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        BasketAccruedOnDefault - This keyword computes the Accrued on Default Leg of CDO Tranche. The first parameter is the underlying Portfolio name. The second parameter is a DateTable object, describing the periodic schedule of t...

        PIT Syntax: BasketAccruedOnDefault( PortfolioName, Schedule, LowerAttachmentPoint, UpperAttachmentPoint, [Recovery] )

        Args:
            portfolioname: The portfolio name
            schedule: dateTable to define the schedule
            lowerattachmentpoint: The Tranche Lower Attachment Point
            upperattachmentpoint: The Tranche Upper Attachment Point
            recovery: The Recovery (optional)

        Returns:
            FunctionCall representing BasketAccruedOnDefault(...)
        """
        args = []
        args.append(portfolioname)
        args.append(schedule)
        args.append(lowerattachmentpoint)
        args.append(upperattachmentpoint)
        if recovery is not None:
            args.append(recovery)
        return FunctionCall("BasketAccruedOnDefault", *args)

    @staticmethod
    def basket_marginal_loss(
        portfolioname: Union[str, float, FormulaExpression],
        lowerattachmentpoint: Union[str, float, FormulaExpression],
        upperattachmentpoint: Union[str, float, FormulaExpression],
        recovery: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        BasketMarginalLoss - This keyword computes the Default Leg of CDO Tranche. The first parameter is the underlying Portfolio name. The last two parameters are the lower and upper attachement points of the tranche.

        PIT Syntax: BasketMarginalLoss( PortfolioName, LowerAttachmentPoint, UpperAttachmentPoint, [Recovery] )

        Args:
            portfolioname: The portfolio name
            lowerattachmentpoint: The Tranche Lower Attachment Point
            upperattachmentpoint: The Tranche Upper Attachment Point
            recovery: The Recovery (optional)

        Returns:
            FunctionCall representing BasketMarginalLoss(...)
        """
        args = []
        args.append(portfolioname)
        args.append(lowerattachmentpoint)
        args.append(upperattachmentpoint)
        if recovery is not None:
            args.append(recovery)
        return FunctionCall("BasketMarginalLoss", *args)

    @staticmethod
    def basket_notional(creditname: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        BasketNotional - Notional of the Basket

        PIT Syntax: BasketNotional( CreditName )

        Args:
            creditname: The credit name

        Returns:
            FunctionCall representing BasketNotional(...)
        """
        return FunctionCall("BasketNotional", creditname)

    @staticmethod
    def name_in_default(portfolioname: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        NameInDefault - Indicates the Name being in default over a portfolio.

        PIT Syntax: NameInDefault( PortfolioName )

        Args:
            portfolioname: The portfolio name

        Returns:
            FunctionCall representing NameInDefault(...)
        """
        return FunctionCall("NameInDefault", portfolioname)

    @staticmethod
    def default_nb(portfolioname: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        DefaultNb - The actual number of defaults over a portfolio.

        PIT Syntax: DefaultNb( PortfolioName )

        Args:
            portfolioname: The portfolio name

        Returns:
            FunctionCall representing DefaultNb(...)
        """
        return FunctionCall("DefaultNb", portfolioname)

    @staticmethod
    def nth_default_date(
        portfolioname: Union[str, float, FormulaExpression],
        index: Union[str, float, FormulaExpression],
        uptothisdate: Union[str, date, FormulaExpression],
        fromthisdate: Union[str, date, FormulaExpression] = "AsOfDate",
    ) -> "FunctionCall":
        """
        NthDefaultDate - This keyword allows to indicate a precise default date occurring over a Credit portfolio. The second parameter indicates the desired default date: if Index is 1, this means that the 1st default occurr...

        PIT Syntax: NthDefaultDate( PortfolioName, Index, [FromThisDate], UpToThisDate )

        Args:
            portfolioname: The portfolio name
            index: Default index
            uptothisdate: Default Maximum Date
            fromthisdate: Default Minimum Date (optional)

        Returns:
            FunctionCall representing NthDefaultDate(...)
        """
        args = []
        args.append(portfolioname)
        args.append(index)
        if fromthisdate is not None:
            args.append(fromthisdate)
        args.append(uptothisdate)
        return FunctionCall("NthDefaultDate", *args)

    @staticmethod
    def tranched_loss_sub_pool(
        portfolioname: Union[str, float, FormulaExpression],
        subportfolioname: Union[str, float, FormulaExpression],
        lowerattachmentpoint: Union[str, float, FormulaExpression],
        upperattachmentpoint: Union[str, float, FormulaExpression],
        recovery: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        TranchedLossSubPool - This keyword computes the Tranched Cumulated Loss over a Credit portfolio. The first parameter is the underlying Portfolio name. The last two parameters are the lower and upper attachement points of t...

        PIT Syntax: TranchedLossSubPool( PortfolioName, SubPortfolioName, LowerAttachmentPoint, UpperAttachmentPoint, [Recovery] )

        Args:
            portfolioname: The portfolio name
            subportfolioname: The sub-portfolio name
            lowerattachmentpoint: The Tranche Lower Attachment Point
            upperattachmentpoint: The Tranche Upper Attachment Point
            recovery: The Recovery (optional)

        Returns:
            FunctionCall representing TranchedLossSubPool(...)
        """
        args = []
        args.append(portfolioname)
        args.append(subportfolioname)
        args.append(lowerattachmentpoint)
        args.append(upperattachmentpoint)
        if recovery is not None:
            args.append(recovery)
        return FunctionCall("TranchedLossSubPool", *args)

    @staticmethod
    def tranched_loss(
        portfolioname: Union[str, float, FormulaExpression],
        lowerattachmentpoint: Union[str, float, FormulaExpression],
        upperattachmentpoint: Union[str, float, FormulaExpression],
        recovery: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        TranchedLoss - This keyword computes the Tranched Cumulated Loss over a Credit portfolio. The first parameter is the underlying Portfolio name. The last two parameters are the lower and upper attachment points of th...

        PIT Syntax: TranchedLoss( PortfolioName, LowerAttachmentPoint, UpperAttachmentPoint, [Recovery] )

        Args:
            portfolioname: The portfolio name
            lowerattachmentpoint: The Tranche Lower Attachment Point
            upperattachmentpoint: The Tranche Upper Attachment Point
            recovery: The Recovery (optional)

        Returns:
            FunctionCall representing TranchedLoss(...)
        """
        args = []
        args.append(portfolioname)
        args.append(lowerattachmentpoint)
        args.append(upperattachmentpoint)
        if recovery is not None:
            args.append(recovery)
        return FunctionCall("TranchedLoss", *args)

    @staticmethod
    def tranche_notional(
        portfolioname: Union[str, float, FormulaExpression],
        lowerattachmentpoint: Union[str, float, FormulaExpression],
        upperattachmentpoint: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        TrancheNotional - Notional of the Tranche

        PIT Syntax: TrancheNotional( PortfolioName, LowerAttachmentPoint, UpperAttachmentPoint )

        Args:
            portfolioname: The portfolio name
            lowerattachmentpoint: The Tranche Lower Attachment Point
            upperattachmentpoint: The Tranche Upper Attachment Point

        Returns:
            FunctionCall representing TrancheNotional(...)
        """
        return FunctionCall("TrancheNotional", portfolioname, lowerattachmentpoint, upperattachmentpoint)

    @staticmethod
    def recovery_on_basket(creditname: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        RecoveryOnBasket - Returns the recovery rate of the name in default over a Basket

        PIT Syntax: RecoveryOnBasket( CreditName )

        Args:
            creditname: The credit name

        Returns:
            FunctionCall representing RecoveryOnBasket(...)
        """
        return FunctionCall("RecoveryOnBasket", creditname)

    @staticmethod
    def recovery(creditname: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Recovery - Returns the recovery rate of the underlying bond of a CDS

        PIT Syntax: Recovery( CreditName )

        Args:
            creditname: The credit name

        Returns:
            FunctionCall representing Recovery(...)
        """
        return FunctionCall("Recovery", creditname)

    @staticmethod
    def cds_rate(
        name: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
        recovery: Union[str, float, FormulaExpression] = "-1",
        frequency: Union[Frequency, str] = "-1",
        daycount: Union[DayCount, str] = "-1",
    ) -> "FunctionCall":
        """
        CDSRate - Credit Default Swap Rate

        PIT Syntax: CDSRate( Name, StartDate, EndDate, [Recovery], [Frequency], [Daycount] )

        Args:
            name: Name
            startdate: CDS Start date
            enddate: CDS End date
            recovery: Recovery rate (optional)
            frequency: Payment frequency (optional)
            daycount: Daycount type (optional)

        Returns:
            FunctionCall representing CDSRate(...)
        """
        args = []
        args.append(name)
        args.append(startdate)
        args.append(enddate)
        if recovery is not None:
            args.append(recovery)
        if frequency is not None:
            args.append(frequency)
        if daycount is not None:
            args.append(daycount)
        return FunctionCall("CDSRate", *args)

    @staticmethod
    def cds_default_leg(
        name: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
    ) -> "FunctionCall":
        """
        CDSDefaultLeg - Credit CDS Default Leg Price

        PIT Syntax: CDSDefaultLeg( Name, StartDate, EndDate )

        Args:
            name: Name
            startdate: CDS Start date
            enddate: CDS End date

        Returns:
            FunctionCall representing CDSDefaultLeg(...)
        """
        return FunctionCall("CDSDefaultLeg", name, startdate, enddate)

    @staticmethod
    def cds_premium_leg(
        name: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str] = "-1",
        daycount: Union[DayCount, str] = "-1",
    ) -> "FunctionCall":
        """
        CDSPremiumLeg - Credit CDS Premium Leg Price

        PIT Syntax: CDSPremiumLeg( Name, StartDate, EndDate, [Frequency], [Daycount] )

        Args:
            name: Name
            startdate: CDS Start date
            enddate: CDS End date
            frequency: Payment frequency (optional)
            daycount: Daycount type (optional)

        Returns:
            FunctionCall representing CDSPremiumLeg(...)
        """
        args = []
        args.append(name)
        args.append(startdate)
        args.append(enddate)
        if frequency is not None:
            args.append(frequency)
        if daycount is not None:
            args.append(daycount)
        return FunctionCall("CDSPremiumLeg", *args)

    @staticmethod
    def cds(
        name: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
        spread: Union[str, float, FormulaExpression],
        recovery: Union[str, float, FormulaExpression] = "-1",
        frequency: Union[Frequency, str] = "-1",
        daycount: Union[DayCount, str] = "-1",
    ) -> "FunctionCall":
        """
        CDS - Credit Default Swap

        PIT Syntax: CDS( Name, StartDate, EndDate, Spread, [Recovery], [Frequency], [Daycount] )

        Args:
            name: Name
            startdate: CDS Start date
            enddate: CDS End date
            spread: Spread of the payment leg
            recovery: Recovery rate (optional)
            frequency: Payment frequency (optional)
            daycount: Daycount type (optional)

        Returns:
            FunctionCall representing CDS(...)
        """
        args = []
        args.append(name)
        args.append(startdate)
        args.append(enddate)
        args.append(spread)
        if recovery is not None:
            args.append(recovery)
        if frequency is not None:
            args.append(frequency)
        if daycount is not None:
            args.append(daycount)
        return FunctionCall("CDS", *args)

    @staticmethod
    def no_default() -> "FunctionCall":
        """
        NoDefault -

        PIT Syntax: NoDefault( UnderlyingName, [ConditionalDate] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing NoDefault(...)
        """
        return FunctionCall("NoDefault")

    @staticmethod
    def tranche_nominal(
        portfolioname: Union[str, float, FormulaExpression],
        lowerattachmentpoint: Union[str, float, FormulaExpression],
        upperattachmentpoint: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        TrancheNominal - (Actual) Nominal of the Tranche

        PIT Syntax: TrancheNominal( PortfolioName, LowerAttachmentPoint, UpperAttachmentPoint )

        Args:
            portfolioname: The portfolio name
            lowerattachmentpoint: The Tranche Lower Attachment Point
            upperattachmentpoint: The Tranche Upper Attachment Point

        Returns:
            FunctionCall representing TrancheNominal(...)
        """
        return FunctionCall("TrancheNominal", portfolioname, lowerattachmentpoint, upperattachmentpoint)

    @staticmethod
    def basket_nominal(creditname: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        BasketNominal - (Actual) Nominal of the Basket

        PIT Syntax: BasketNominal( CreditName )

        Args:
            creditname: The credit name

        Returns:
            FunctionCall representing BasketNominal(...)
        """
        return FunctionCall("BasketNominal", creditname)

    @staticmethod
    def cds_protection_leg(
        name: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str] = "-1",
        daycount: Union[DayCount, str] = "-1",
    ) -> "FunctionCall":
        """
        CDSProtectionLeg - Credit CDS Premium Leg Price

        PIT Syntax: CDSProtectionLeg( Name, StartDate, EndDate, [Frequency], [Daycount] )

        Args:
            name: Name
            startdate: CDS Start date
            enddate: CDS End date
            frequency: Payment frequency (optional)
            daycount: Daycount type (optional)

        Returns:
            FunctionCall representing CDSProtectionLeg(...)
        """
        args = []
        args.append(name)
        args.append(startdate)
        args.append(enddate)
        if frequency is not None:
            args.append(frequency)
        if daycount is not None:
            args.append(daycount)
        return FunctionCall("CDSProtectionLeg", *args)

    @staticmethod
    def accrued_on_default_index(
        model: Union[str, float, FormulaExpression], datetable: Union[str, date, FormulaExpression]
    ) -> "FunctionCall":
        """
        AccruedOnDefaultIndex - This keyword computes the time lag between a default time and the previous date of a periodic schedule. The default date is the default date of a single CDS or of a CDS belonging to a Portfolio. The c...

        PIT Syntax: AccruedOnDefaultIndex( Model, DateTable )

        Args:
            model: The name of a Credit instrument. It may be a CDS ticker or a Credit Portfolio name.
            datetable: DateTable object to define the schedule.

        Returns:
            FunctionCall representing AccruedOnDefaultIndex(...)
        """
        return FunctionCall("AccruedOnDefaultIndex", model, datetable)

    @staticmethod
    def no_default_index() -> "FunctionCall":
        """
        NoDefaultIndex -

        PIT Syntax: NoDefaultIndex( UnderlyingName, [ConditionalDate] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing NoDefaultIndex(...)
        """
        return FunctionCall("NoDefaultIndex")

    @staticmethod
    def get_rating(name: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        GetRating - The GetRating enables to retrieve the current rating of an underlying.          This keyword has only the underlying's name as parameter and returns a integer corresponding to the current rat...

        PIT Syntax: GetRating( Name )

        Args:
            name: Name

        Returns:
            FunctionCall representing GetRating(...)
        """
        return FunctionCall("GetRating", name)

    @staticmethod
    def z_spread(
        name: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
    ) -> "FunctionCall":
        """
        ZSpread - The ZSpread keyword is a pseudo-keyword which retrieves the Z-Spread from the credit curve passed to the security           (parameter: 'creditSpreadsCurve') if the flag 'ZSpread' is chosen...

        PIT Syntax: ZSpread( Name, StartDate, EndDate )

        Args:
            name: Name
            startdate: ZSpread Start date
            enddate: ZSpread End date

        Returns:
            FunctionCall representing ZSpread(...)
        """
        return FunctionCall("ZSpread", name, startdate, enddate)

    @staticmethod
    def survival_proba() -> "FunctionCall":
        """
        SurvivalProba -

        PIT Syntax: SurvivalProba( UnderlyingName )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing SurvivalProba(...)
        """
        return FunctionCall("SurvivalProba")

    @staticmethod
    def eq_spot(
        model: Union[str, float, FormulaExpression],
        fixing_type: Union[str, float, FormulaExpression] = None,
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        EqSpot - This keyword needs only one argument, which is the name of the underlying, and returns its spot at current date. This is by far the most useful in equity world. If pricing is done with a multi asset m...

        PIT Syntax: EqSpot( Model , [Fixing type ], [Settlement Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            fixing_type: Fixing type (either CLOSE, HIGH, LOW, etc..) (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)

        Returns:
            FunctionCall representing EqSpot(...)
        """
        args = []
        args.append(model)
        if fixing_type is not None:
            args.append(fixing_type)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        return FunctionCall("EqSpot", *args)

    @staticmethod
    def eq_fwd(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        EqFwd - Equity Forward

        PIT Syntax: EqFwd( Model , Expiry Date , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry date of the forward
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing EqFwd(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("EqFwd", *args)

    @staticmethod
    def eq_call(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        EqCall - Prices a call/put on an equity. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If the Heston m...

        PIT Syntax: EqCall( Model , Expiry Date , Strike , Call/Put , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing EqCall(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("EqCall", *args)

    @staticmethod
    def eq_digital(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression] = "1",
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        EqDigital - Prices a digital option on an equity. A digital call pays 1 if the spot is higher that the strike and 0 otherwise. The price of the contract is computed in closed form by the used model. If, for ex, t...

        PIT Syntax: EqDigital( Model , Expiry Date , Strike , Call/Put , [Notional ], [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the forward
            strike: Call strike in real terms
            call_put: Option's type CALL or PUT (Digital Case)
            notional: Notional of the digital (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing EqDigital(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        if notional is not None:
            args.append(notional)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("EqDigital", *args)

    @staticmethod
    def eq_bs_vol(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        EqBSVol - Returns the corresponding Black Scholes volatility for a given call or put on an equity. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Sch...

        PIT Syntax: EqBSVol( Model , Expiry Date , Strike , Call/Put , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing EqBSVol(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("EqBSVol", *args)

    @staticmethod
    def eq_histo_vol(
        model: Union[str, float, FormulaExpression], histo_maturity: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        EqHistoVol - Equity historical volatility

        PIT Syntax: EqHistoVol( Model , histo maturity )

        Args:
            model: The model to compute the spot value with
            histo_maturity: Maturity for the histo vol

        Returns:
            FunctionCall representing EqHistoVol(...)
        """
        return FunctionCall("EqHistoVol", model, histo_maturity)

    @staticmethod
    def eq_paid_dividends() -> "FunctionCall":
        """
        EqPaidDividends -

        PIT Syntax: EqPaidDividends( Model , [Dividend Period Start Date or Maturity], [Dividend Period End Date or Maturity ], [Takes discounted Dividend?], [Exclude Start Date?], [Exclude End Date?] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing EqPaidDividends(...)
        """
        return FunctionCall("EqPaidDividends")

    @staticmethod
    def eq_var_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        calendar: Union[Calendar, str] = "NoCalendar",
        annualisation_factor: Union[str, float, FormulaExpression] = "-1",
        interpolation_type: Union[str, float, FormulaExpression] = "STD",
        dividend_adjustment: Union[DateRule, str] = "NONE",
        capped: Union[str, float, FormulaExpression] = "False",
        strike_capped: Union[str, float, FormulaExpression] = "0",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        parametric: Union[str, float, FormulaExpression] = "False",
    ) -> "FunctionCall":
        """
        EqVarSwap - Equity variance Swap

        PIT Syntax: EqVarSwap( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Calendar], [Annualisation Factor ], [Interpolation Type ], [Dividend Adjustment], [Capped], [Strike Capped], [Implied Volatility], [parametric] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance swap strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            calendar: Calendar (optional)
            annualisation_factor: Number of business days per year, default 252 (optional)
            interpolation_type: Interpolation Type (optional)
            dividend_adjustment: Dividend adjustment method on historical realized variance (optional)
            capped: Is the swap capped? If true, you need to provide the strike (optional)
            strike_capped: Strike value in case the swap is capped (optional)
            implied_volatility: Market Implied Volatility (optional)
            parametric: Is the swap computed parametrically? If true, you need to use the Heston model (optional)

        Returns:
            FunctionCall representing EqVarSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if calendar is not None:
            args.append(calendar)
        if annualisation_factor is not None:
            args.append(annualisation_factor)
        if interpolation_type is not None:
            args.append(interpolation_type)
        if dividend_adjustment is not None:
            args.append(dividend_adjustment)
        if capped is not None:
            args.append(capped)
        if strike_capped is not None:
            args.append(strike_capped)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if parametric is not None:
            args.append(parametric)
        return FunctionCall("EqVarSwap", *args)

    @staticmethod
    def eq_vol_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        calendar: Union[Calendar, str] = "NoCalendar",
        capped: Union[str, float, FormulaExpression] = "False",
        strike_capped: Union[str, float, FormulaExpression] = "0",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        dividend_adjustment: Union[DateRule, str] = "NONE",
        parametric: Union[str, float, FormulaExpression] = "False",
    ) -> "FunctionCall":
        """
        EqVolSwap - Equity volatility Swap

        PIT Syntax: EqVolSwap( Model, Start Date, Expiry Date, Frequency, Strike, Notional, [Calendar], [Capped], [Strike Capped], [Implied Volatility], [Dividend Adjustment], [parametric] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Volatility swap strike
            notional: Notional
            calendar: Calendar (optional)
            capped: Is the swap capped? If true, you need to provide the strike (optional)
            strike_capped: Strike value in case the swap is capped (optional)
            implied_volatility: Market Implied Volatility (optional)
            dividend_adjustment: Dividend adjustment method on historical realized variance (optional)
            parametric: Is the swap computed parametrically? If true, you need to use the Heston model (optional)

        Returns:
            FunctionCall representing EqVolSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if calendar is not None:
            args.append(calendar)
        if capped is not None:
            args.append(capped)
        if strike_capped is not None:
            args.append(strike_capped)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if dividend_adjustment is not None:
            args.append(dividend_adjustment)
        if parametric is not None:
            args.append(parametric)
        return FunctionCall("EqVolSwap", *args)

    @staticmethod
    def eq_var_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        calendar: Union[Calendar, str] = "NoCalendar",
        dividend_adjustment: Union[DateRule, str] = "NONE",
    ) -> "FunctionCall":
        """
        EqVarOption - Equity variance call

        PIT Syntax: EqVarOption( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Implied Volatility ], [Calendar], [Dividend Adjustment] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance option strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            implied_volatility: Market Implied Volatility (optional)
            calendar: Calendar (optional)
            dividend_adjustment: Dividend adjustment method on historical realized variance (optional)

        Returns:
            FunctionCall representing EqVarOption(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if calendar is not None:
            args.append(calendar)
        if dividend_adjustment is not None:
            args.append(dividend_adjustment)
        return FunctionCall("EqVarOption", *args)

    @staticmethod
    def eq_vol_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        calendar: Union[Calendar, str] = "NoCalendar",
        dividend_adjustment: Union[DateRule, str] = "NONE",
    ) -> "FunctionCall":
        """
        EqVolOption - Equity volatility call

        PIT Syntax: EqVolOption( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Implied Volatility ], [Calendar], [Dividend Adjustment] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Volatility option strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            implied_volatility: Market Implied Volatility (optional)
            calendar: Calendar (optional)
            dividend_adjustment: Dividend adjustment method on historical realized variance (optional)

        Returns:
            FunctionCall representing EqVolOption(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if calendar is not None:
            args.append(calendar)
        if dividend_adjustment is not None:
            args.append(dividend_adjustment)
        return FunctionCall("EqVolOption", *args)

    @staticmethod
    def eq_corridor_var_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        calendar: Union[Calendar, str] = "NoCalendar",
        annualisation_factor: Union[str, float, FormulaExpression] = "-1",
        lower_barrier: Union[str, float, FormulaExpression] = None,
        upper_barrier: Union[str, float, FormulaExpression] = None,
        bounds_date: Union[str, date, FormulaExpression] = "CURRENT_TIME",
        computation_method: Union[str, float, FormulaExpression] = "SPOT_REPL",
        use_adjusted_strike: Union[DateRule, str] = "False",
        dividend_adjustment: Union[DateRule, str] = "NONE",
    ) -> "FunctionCall":
        """
        EqCorridorVarSwap - Equity corridor variance Swap

        PIT Syntax: EqCorridorVarSwap( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Calendar], [Annualisation Factor ], [Lower Barrier ], [Upper Barrier ], [Bounds Date], [Computation Method], [Use Adjusted Strike], [Dividend Adjustment] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance swap strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            calendar: Calendar (optional)
            annualisation_factor: Number of business days per year, default 252 (optional)
            lower_barrier: The lower corridor level (optional)
            upper_barrier: The upper corridor level (optional)
            bounds_date: Should we apply the corridor barriers to the current date, previous date or both? (optional)
            computation_method: Computation method of the corridor variance swap price (among pseudo analytic ones) (optional)
            use_adjusted_strike: Multiply or no the fixed leg by the ratio between the sum of corridor digitals and total number of days (optional)
            dividend_adjustment: Dividend adjustment method on historical realized variance (optional)

        Returns:
            FunctionCall representing EqCorridorVarSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if calendar is not None:
            args.append(calendar)
        if annualisation_factor is not None:
            args.append(annualisation_factor)
        if lower_barrier is not None:
            args.append(lower_barrier)
        if upper_barrier is not None:
            args.append(upper_barrier)
        if bounds_date is not None:
            args.append(bounds_date)
        if computation_method is not None:
            args.append(computation_method)
        if use_adjusted_strike is not None:
            args.append(use_adjusted_strike)
        if dividend_adjustment is not None:
            args.append(dividend_adjustment)
        return FunctionCall("EqCorridorVarSwap", *args)

    @staticmethod
    def eq_spot_corridor(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression] = "AsOfDate",
        end_date: Union[str, date, FormulaExpression] = "AsOfDate",
        down_barrier: Union[str, float, FormulaExpression] = "0",
        up_barrier: Union[str, float, FormulaExpression] = "1e20",
        spot: Union[str, float, FormulaExpression] = "1e20",
        strike_of_calibration: Union[str, float, FormulaExpression] = "1e20",
        observation_period: Union[str, float, FormulaExpression] = "1BD",
        bounds_type: Union[str, float, FormulaExpression] = "CURRENT_AND_PREV",
        calendar: Union[Calendar, str] = "UnderlyingCalendar",
    ) -> "FunctionCall":
        """
        EqSpotCorridor - Computes how many times the Eq Spot was inside the corridor according to the given accounting procedure.

        PIT Syntax: EqSpotCorridor( Model , [Start date], [End date], [Down barrier ], [Up barrier ], [Spot ], [Strike of calibration ], [Observation period ], [Bounds type ], [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start date (optional)
            end_date: End date (optional)
            down_barrier: Default 0.0 (optional)
            up_barrier: Default big number = 1e20 (optional)
            spot: Default big number = 1e20 (optional)
            strike_of_calibration: Default big number = 1e20 (optional)
            observation_period: Default = 1BD (optional)
            bounds_type: Default = 1BD (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing EqSpotCorridor(...)
        """
        args = []
        args.append(model)
        if start_date is not None:
            args.append(start_date)
        if end_date is not None:
            args.append(end_date)
        if down_barrier is not None:
            args.append(down_barrier)
        if up_barrier is not None:
            args.append(up_barrier)
        if spot is not None:
            args.append(spot)
        if strike_of_calibration is not None:
            args.append(strike_of_calibration)
        if observation_period is not None:
            args.append(observation_period)
        if bounds_type is not None:
            args.append(bounds_type)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("EqSpotCorridor", *args)

    @staticmethod
    def eq_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        rebate: Union[str, float, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        EqBarrier - Prices analytically a classical barrier option on a equity. The barrier can be monitored continuously or discretely between the start date and end date. Actually, this keyword works uniquely for Black...

        PIT Syntax: EqBarrier( Model , Expiry Date , Strike , Call/Put , Barrier , Barrier Type , [StartDate ], [EndDate ], [Rebate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            rebate: Rebate (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing EqBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(barrier)
        args.append(barrier_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if rebate is not None:
            args.append(rebate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("EqBarrier", *args)

    @staticmethod
    def eq_double_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        lowbarrier: Union[str, float, FormulaExpression],
        upbarrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        EqDoubleBarrier - Prices analytically a double barrier option on a equity. The barriers can be monitored continuously or discretely between the start date and end date. Actually, this keyword works uniquely for Black-S...

        PIT Syntax: EqDoubleBarrier( Model , Expiry Date , Strike , Call/Put , LowBarrier , UpBarrier , Barrier Type , [StartDate ], [EndDate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            lowbarrier: Lower Barrier level
            upbarrier: Upper Barrier level
            barrier_type: Barrier's type KNOCKIN or KNOCKOUT
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing EqDoubleBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(lowbarrier)
        args.append(upbarrier)
        args.append(barrier_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("EqDoubleBarrier", *args)

    @staticmethod
    def eq_digital_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        payoff_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        EqDigitalBarrier - Prices analytically a digital barrier option on a equity. The barrier can be monitored continuously or discretely between the start date and end date. Actually, this keyword works uniquely for Black-S...

        PIT Syntax: EqDigitalBarrier( Model , Expiry Date , Strike , Call/Put , Barrier , Barrier Type , Payoff Type , [StartDate ], [EndDate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            payoff_type: Barrier's type CASH or ASSET
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing EqDigitalBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(barrier)
        args.append(barrier_type)
        args.append(payoff_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("EqDigitalBarrier", *args)

    @staticmethod
    def equity_shifted_barrier(
        model: Union[str, float, FormulaExpression],
        spot: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        frequency: Union[Frequency, str] = "Daily",
        currentdate: Union[str, date, FormulaExpression] = "0",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        EquityShiftedBarrier - This keyword computes the adjusted stochastic barrier at which the discrete barrier option price matches with the continuous monitoring one at initial barrier level

        PIT Syntax: EqShiftedBarrier( Model , Spot , Barrier , Barrier Type , [Frequency ], [CurrentDate ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            spot: Current Spot level
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            frequency: Frequency of discrete barrier 1D, 2D, 3D, 4D, 5D, W,... (optional)
            currentdate: Current Date for barrier monitoring (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing EquityShiftedBarrier(...)
        """
        args = []
        args.append(model)
        args.append(spot)
        args.append(barrier)
        args.append(barrier_type)
        if frequency is not None:
            args.append(frequency)
        if currentdate is not None:
            args.append(currentdate)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("EquityShiftedBarrier", *args)

    @staticmethod
    def eq_power_option(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        power: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        EqPowerOption - Prices a power option on an equity. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If the Hest...

        PIT Syntax: EqPowerOption( Model , Expiry Date , Strike , Power , Call/Put , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Option strike in real terms
            power: Power coefficient
            call_put: Option's type Call or Put
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing EqPowerOption(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(power)
        args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("EqPowerOption", *args)

    @staticmethod
    def eq_asian_option(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        method: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression],
        enddate: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        EqAsianOption - The keyword prices analytically a classical Asian option on a equity between the start date and end date. One of the following methods should be given : Curran, Ju or Sophis. Sophis 's approximation c...

        PIT Syntax: EqAsianOption( Model , Expiry Date , Strike , Call/Put , Method , StartDate , EndDate , Frequency , [Calendar ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            method: Method : Curran, Ju or Sophis
            startdate: Start Date for Asian monitoring
            enddate: End Date for Asian monitoring
            frequency: Asian's Frequency 1D, 2D, 3D, 4D, 5D, W,...
            calendar: Asian's Calendar (optional)

        Returns:
            FunctionCall representing EqAsianOption(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(method)
        args.append(startdate)
        args.append(enddate)
        args.append(frequency)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("EqAsianOption", *args)

    @staticmethod
    def eq_american_call(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        calculation_method: Union[str, float, FormulaExpression],
        call_frequency: Union[Frequency, str] = "Daily",
        premium_only: Union[str, float, FormulaExpression] = "0",
    ) -> "FunctionCall":
        """
        EqAmericanCall - Prices a american call/put on an equity. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If the...

        PIT Syntax: EqAmericanOption( Model , Expiry Date , Strike , Call/Put , Calculation Method , [Call frequency ], [Premium Only ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            calculation_method: Method to compute the option
            call_frequency: The callability frequency (optional)
            premium_only: If true returns the early exercise premium only (optional)

        Returns:
            FunctionCall representing EqAmericanCall(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(calculation_method)
        if call_frequency is not None:
            args.append(call_frequency)
        if premium_only is not None:
            args.append(premium_only)
        return FunctionCall("EqAmericanCall", *args)

    @staticmethod
    def index() -> "FunctionCall":
        """
        Index -

        PIT Syntax: Index( Model , [Fixing type ], [Settlement Gap or Date ] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Index(...)
        """
        return FunctionCall("Index")

    @staticmethod
    def fx_spot(
        model: Union[str, float, FormulaExpression],
        fixing_type: Union[str, float, FormulaExpression] = None,
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        FxSpot - This keyword needs only one argument, which is the name of the exchange rate, and returns its value at current date. If pricing is done with a multi asset model, it corresponds to the name of the mode...

        PIT Syntax: FxSpot( Model , [Fixing type ], [Settlement Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            fixing_type: Fixing type (either CLOSE, HIGH, LOW, etc..) (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)

        Returns:
            FunctionCall representing FxSpot(...)
        """
        args = []
        args.append(model)
        if fixing_type is not None:
            args.append(fixing_type)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        return FunctionCall("FxSpot", *args)

    @staticmethod
    def fx_rate(
        model: Union[str, float, FormulaExpression],
        date: Union[str, date, FormulaExpression],
        fixing_type: Union[str, float, FormulaExpression] = None,
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        FxRate - This keyword needs two arguments, 1st is the name of the exchange rate, and 2nd is the date at wich the rate as requested, and it returns the value at requested date. If pricing is done with a multi a...

        PIT Syntax: FxRate( Model , Date , [Fixing type ], [Settlement Gap or Date ] )

        Args:
            model: The model to compute the FX Rate value with
            date: The date at which the FX Rate is requested
            fixing_type: Fixing type (either CLOSE, HIGH, LOW, etc..) (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)

        Returns:
            FunctionCall representing FxRate(...)
        """
        args = []
        args.append(model)
        args.append(date)
        if fixing_type is not None:
            args.append(fixing_type)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        return FunctionCall("FxRate", *args)

    @staticmethod
    def fx_fwd(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        FxFwd - Gives the forward of a forex. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If the Heston mod...

        PIT Syntax: FxFwd( Model , Expiry Date , [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry date of the forward
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing FxFwd(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("FxFwd", *args)

    @staticmethod
    def fx_call(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression] = "Call",
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        FxCall - Prices a call/put on a forex. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If the Heston mod...

        PIT Syntax: FxCall( Model , Expiry Date , Strike , [Call/Put ], [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing FxCall(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        if call_put is not None:
            args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("FxCall", *args)

    @staticmethod
    def fx_digital(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression] = "Call",
        notional: Union[str, float, FormulaExpression] = "1",
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        FxDigital - Prices a digital on an Fx. A digital call pays 1 if the spot is higher that the strike and 0 otherwise. The price of the contract is computed in closed form by the used model. If, for ex, the used mod...

        PIT Syntax: FxDigital( Model , Expiry Date , Strike , [Call/Put ], [Notional ], [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the forward
            strike: Call strike in real terms
            call_put: Option's type CALL or PUT (Digital Case) (optional)
            notional: Notional of the digital (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing FxDigital(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        if call_put is not None:
            args.append(call_put)
        if notional is not None:
            args.append(notional)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("FxDigital", *args)

    @staticmethod
    def fx_histo_vol(
        model: Union[str, float, FormulaExpression], histo_maturity: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        FxHistoVol - FX historical volatilty

        PIT Syntax: FxHistoVol( Model , histo maturity )

        Args:
            model: The model to compute the spot value with
            histo_maturity: Maturity for the histo vol

        Returns:
            FunctionCall representing FxHistoVol(...)
        """
        return FunctionCall("FxHistoVol", model, histo_maturity)

    @staticmethod
    def fx_bs_vol(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression] = "Call",
        settlement_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
        payment_gap_or_date: Union[str, date, FormulaExpression] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        FxBSVol - Returns the corresponding Black Scholes volatility for a given call or put on an Fx. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes...

        PIT Syntax: FxBSVol( Model , Expiry Date , Strike , [Call/Put ], [Settlement Gap or Date ], [Payment Gap or Date ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put (optional)
            settlement_gap_or_date: Settlement date or number of days between expiry and settlement date (optional)
            payment_gap_or_date: Payment date or number of days between expiry and payment date (optional)

        Returns:
            FunctionCall representing FxBSVol(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        if call_put is not None:
            args.append(call_put)
        if settlement_gap_or_date is not None:
            args.append(settlement_gap_or_date)
        if payment_gap_or_date is not None:
            args.append(payment_gap_or_date)
        return FunctionCall("FxBSVol", *args)

    @staticmethod
    def fx_var_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        FxVarSwap - FX variance Swap

        PIT Syntax: FxVarSwap( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Calendar] )

        Args:
            model: Name of the model to compute the VarSwap
            start_date: Start Date of the VarSwap
            expiry_date: Expiry Date of the VarSwap
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance swap strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing FxVarSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("FxVarSwap", *args)

    @staticmethod
    def fx_vol_swap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        FxVolSwap - FX volatility Swap

        PIT Syntax: FxVolSwap( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Volatility swap strike
            notional: Notional
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing FxVolSwap(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("FxVolSwap", *args)

    @staticmethod
    def fx_var_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        FxVarOption - FX variance call

        PIT Syntax: FxVarOption( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Implied Volatility ], [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Variance option strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            implied_volatility: Market Implied Volatility (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing FxVarOption(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("FxVarOption", *args)

    @staticmethod
    def fx_vol_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        implied_volatility: Union[str, float, FormulaExpression] = "0",
        calendar: Union[Calendar, str] = "NoCalendar",
    ) -> "FunctionCall":
        """
        FxVolOption - FX volatility call

        PIT Syntax: FxVolOption( Model , Start Date , Expiry Date , Frequency , Strike , Notional , [NotionalType ], [Implied Volatility ], [Calendar] )

        Args:
            model: The model to compute the spot value with
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            strike: Volatility option strike
            notional: Notional
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            implied_volatility: Market Implied Volatility (optional)
            calendar: Calendar (optional)

        Returns:
            FunctionCall representing FxVolOption(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(strike)
        args.append(notional)
        if notionaltype is not None:
            args.append(notionaltype)
        if implied_volatility is not None:
            args.append(implied_volatility)
        if calendar is not None:
            args.append(calendar)
        return FunctionCall("FxVolOption", *args)

    @staticmethod
    def fx_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        rebate: Union[str, float, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        FxBarrier - Prices analytically a classical barrier option on a forex. The barrier can be monitored continuously or discretely between the start date and end date. Actually, this keyword works uniquely for Black-...

        PIT Syntax: FxBarrier( Model , Expiry Date , Strike , Call/Put , Barrier , Barrier Type , [StartDate ], [EndDate ], [Rebate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            rebate: Rebate (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing FxBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(barrier)
        args.append(barrier_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if rebate is not None:
            args.append(rebate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("FxBarrier", *args)

    @staticmethod
    def fx_double_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        lowbarrier: Union[str, float, FormulaExpression],
        upbarrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        FxDoubleBarrier - Prices analytically a double barrier option on a forex. The barriers can be monitored continuously or discretely between the start date and end date. Actually, this keyword works uniquely for Black-Sc...

        PIT Syntax: FxDoubleBarrier( Model , Expiry Date , Strike , Call/Put , LowBarrier , UpBarrier , Barrier Type , [StartDate ], [EndDate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            lowbarrier: Lower Barrier level
            upbarrier: Upper Barrier level
            barrier_type: Barrier's type KNOCKIN or KNOCKOUT
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing FxDoubleBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(lowbarrier)
        args.append(upbarrier)
        args.append(barrier_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("FxDoubleBarrier", *args)

    @staticmethod
    def fx_digital_barrier(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        payoff_type: Union[str, float, FormulaExpression],
        startdate: Union[str, date, FormulaExpression] = "0",
        enddate: Union[str, date, FormulaExpression] = "0",
        continuous_discrete: Union[str, float, FormulaExpression] = "Yes",
        frequency: Union[Frequency, str] = "Daily",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        FxDigitalBarrier - Prices analytically a digital barrier option on a forex. The barrier can be monitored continuously or discretely between the start date and end date. Actually, this keyword works uniquely for Black-Sc...

        PIT Syntax: FxDigitalBarrier( Model , Expiry Date , Strike , Call/Put , Barrier , Barrier Type , Payoff Type , [StartDate ], [EndDate ], [Continuous/discrete ], [Frequency ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            payoff_type: Barrier's type CASH or ASSET
            startdate: Start Date for barrier monitoring (optional)
            enddate: End Date for barrier monitoring (optional)
            continuous_discrete: Option's type YES for Continuous and NO for discrete (optional)
            frequency: Barrier's Frequency 1D, 2D, 3D, 4D, 5D, W,... (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing FxDigitalBarrier(...)
        """
        args = []
        args.append(model)
        args.append(expiry_date)
        args.append(strike)
        args.append(call_put)
        args.append(barrier)
        args.append(barrier_type)
        args.append(payoff_type)
        if startdate is not None:
            args.append(startdate)
        if enddate is not None:
            args.append(enddate)
        if continuous_discrete is not None:
            args.append(continuous_discrete)
        if frequency is not None:
            args.append(frequency)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("FxDigitalBarrier", *args)

    @staticmethod
    def fx_shifted_barrier(
        model: Union[str, float, FormulaExpression],
        spot: Union[str, float, FormulaExpression],
        barrier: Union[str, float, FormulaExpression],
        barrier_type: Union[str, float, FormulaExpression],
        frequency: Union[Frequency, str] = "Daily",
        currentdate: Union[str, date, FormulaExpression] = "0",
        users_volatility: Union[str, float, FormulaExpression] = "-1",
    ) -> "FunctionCall":
        """
        FxShiftedBarrier - This keyword computes the adjusted stochastic barrier at which the discrete barrier option price matches with the continuous monitoring one at initial barrier level

        PIT Syntax: FxShiftedBarrier( Model , Spot , Barrier , Barrier Type , [Frequency ], [CurrentDate ], [User's volatility ] )

        Args:
            model: The model to compute the spot value with
            spot: Current Spot level
            barrier: Barrier level
            barrier_type: Barrier's type DOWN_AND_IN, UP_AND_IN, DOWN_AND_OUT, UP_AND_OUT
            frequency: Frequency of discrete barrier 1D, 2D, 3D, 4D, 5D, W,... (optional)
            currentdate: Current Date for barrier monitoring (optional)
            users_volatility: Volatility given by user (optional)

        Returns:
            FunctionCall representing FxShiftedBarrier(...)
        """
        args = []
        args.append(model)
        args.append(spot)
        args.append(barrier)
        args.append(barrier_type)
        if frequency is not None:
            args.append(frequency)
        if currentdate is not None:
            args.append(currentdate)
        if users_volatility is not None:
            args.append(users_volatility)
        return FunctionCall("FxShiftedBarrier", *args)

    @staticmethod
    def fx_american_call(
        model: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        calculation_method: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        FxAmericanCall - Prices an American call/put on an forex. The price of the contract is computed in closed form by the used model. If, for ex, the used model is Black Scholes, Black Scholes formula will be used. If the...

        PIT Syntax: FxAmericanOption( Model , Expiry Date , Strike , Call/Put , Calculation Method )

        Args:
            model: The model to compute the spot value with
            expiry_date: Expiry Date of the option
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            calculation_method: Method to compute the option

        Returns:
            FunctionCall representing FxAmericanCall(...)
        """
        return FunctionCall("FxAmericanCall", model, expiry_date, strike, call_put, calculation_method)

    @staticmethod
    def annuity(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        frequency_period: Union[Frequency, str] = None,
        days_count: Union[DayCount, str] = None,
    ) -> "FunctionCall":
        """
        Annuity - Computes the present value of an annuity stream

        PIT Syntax: Annuity( Currency, Start Date, Tenor or End Date, [Frequency period], [Days count] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date of the annuity
            tenor_or_end_date: Tenor (e.g., '5y', '10y') or explicit end date
            frequency_period: Payment frequency (e.g., Frequency.ANNUAL, Frequency.SEMI_ANNUAL) (optional)
            days_count: Day count convention (e.g., DayCount.ACT_360, DayCount.THIRTY_360) (optional)

        Returns:
            FunctionCall representing Annuity(...)
        """
        args = [currency, start_date, tenor_or_end_date]
        if frequency_period is not None:
            args.append(frequency_period)
        if days_count is not None:
            args.append(days_count)
        return FunctionCall("Annuity", *args)

    @staticmethod
    def bond_keyword(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        coupon_or_spread: Union[str, float, FormulaExpression],
        coupon_type: Union[str, float, FormulaExpression] = None,
        frequency: Union[Frequency, str] = None,
        days_count: Union[DayCount, str] = None,
    ) -> "FunctionCall":
        """
        BondKeyword - Prices a fixed coupon bond

        PIT Syntax: Bond( Currency, Start Date, Tenor or End Date, Coupon or Spread, [Coupon type], [Frequency], [Days count] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date of the bond
            tenor_or_end_date: Tenor (e.g., '5y', '10y') or explicit end date
            coupon_or_spread: Coupon rate or spread over benchmark
            coupon_type: Type of coupon (e.g., 'Fixed', 'Floating') (optional)
            frequency: Payment frequency (e.g., Frequency.ANNUAL, Frequency.SEMI_ANNUAL) (optional)
            days_count: Day count convention (e.g., DayCount.ACTUAL_360, DayCount.THIRTY_360) (optional)

        Returns:
            FunctionCall representing BondKeyword(...)
        """
        args = [currency, start_date, tenor_or_end_date, coupon_or_spread]
        if coupon_type is not None:
            args.append(coupon_type)
        if frequency is not None:
            args.append(frequency)
        if days_count is not None:
            args.append(days_count)
        return FunctionCall("BondKeyword", *args)

    @staticmethod
    def cap(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        cap_floor: Union[str, float, FormulaExpression],
        frequency_period: Union[Frequency, str] = None,
        cpn_days_count: Union[DayCount, str] = None,
        reset_gap: Union[str, float, FormulaExpression] = None,
        pay_gap: Union[str, float, FormulaExpression] = None,
        option_notional: Union[str, float, FormulaExpression] = None,
        reset_timing: Union[ResetTiming, str] = None,
        index_term: Union[str, float, FormulaExpression] = None,
        index_days_count: Union[DayCount, str] = None,
        convexity_adjustment_method: Union[str, float, FormulaExpression] = None,
        is_digital_option: Union[str, float, FormulaExpression] = None,
        report_configuration: Union[str, float, FormulaExpression] = None,
        is_rfr_cap_floor: Union[str, float, FormulaExpression] = None,
        is_adjusted: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        Cap - Prices an interest rate cap or floor

         PIT Syntax: Cap( Model, Start Date, Maturity or End Date, Strike, Cap/Floor, [Frequency period], [Cpn Days count], [Reset Gap], [Pay Gap], [Option's notional], [Reset Timing], [Index Term], [Index Days count], [Convexity Adjustment Method], [Is Digital Option], [Report Configuration], [Is RFR Cap/Floor], [Is adjusted] )

         Args:
             model: The pricing model to use
             start_date: Start date of the cap/floor
             maturity_or_end_date: Maturity tenor or explicit end date
             strike: Strike rate
             cap_floor: 'Cap' or 'Floor'
             frequency_period: Coupon payment frequency (optional)
             cpn_days_count: Coupon day count convention (optional)
             reset_gap: Reset gap in days (optional)
             pay_gap: Payment gap in days (optional)
             option_notional: Notional amount (optional)
             reset_timing: Reset timing (e.g., ResetTiming.ADVANCE, ResetTiming.ARREARS) (optional)
             index_term: Underlying index tenor (optional)
             index_days_count: Index day count convention (optional)
             convexity_adjustment_method: Convexity adjustment method (optional)
             is_digital_option: Whether this is a digital cap/floor (optional)
             report_configuration: Reporting configuration (optional)
             is_rfr_cap_floor: Whether this is an RFR-based cap/floor (optional)
             is_adjusted: Whether rates are adjusted (optional)

         Returns:
             FunctionCall representing Cap(...)
        """
        args = [model, start_date, maturity_or_end_date, strike, cap_floor]
        if frequency_period is not None:
            args.append(frequency_period)
        if cpn_days_count is not None:
            args.append(cpn_days_count)
        if reset_gap is not None:
            args.append(reset_gap)
        if pay_gap is not None:
            args.append(pay_gap)
        if option_notional is not None:
            args.append(option_notional)
        if reset_timing is not None:
            args.append(reset_timing)
        if index_term is not None:
            args.append(index_term)
        if index_days_count is not None:
            args.append(index_days_count)
        if convexity_adjustment_method is not None:
            args.append(convexity_adjustment_method)
        if is_digital_option is not None:
            args.append(is_digital_option)
        if report_configuration is not None:
            args.append(report_configuration)
        if is_rfr_cap_floor is not None:
            args.append(is_rfr_cap_floor)
        if is_adjusted is not None:
            args.append(is_adjusted)
        return FunctionCall("Cap", *args)

    @staticmethod
    def cap_power(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        power: Union[str, float, FormulaExpression],
        cap_floor: Union[str, float, FormulaExpression],
        frequency_period: Union[Frequency, str] = None,
        cpn_days_count: Union[DayCount, str] = None,
        reset_gap: Union[str, float, FormulaExpression] = None,
        pay_gap: Union[str, float, FormulaExpression] = None,
        option_notional: Union[str, float, FormulaExpression] = None,
        reset_timing: Union[ResetTiming, str] = None,
        index_term: Union[str, float, FormulaExpression] = None,
        index_days_count: Union[DayCount, str] = None,
        convexity_adjustment_method: Union[str, float, FormulaExpression] = None,
        report_configuration: Union[str, float, FormulaExpression] = None,
        sensibility_bump_value: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        CapPower - Prices a power cap/floor

        PIT Syntax: CapPower( Model, Start Date, Maturity or End Date, Strike, Power, Cap/Floor, [Frequency period], [Cpn Days count], [Reset Gap], [Pay Gap], [Option's notional], [Reset Timing], [Index Term], [Index Days count], [Convexity Adjustment Method], [Report Configuration], [Sensibility bump value] )

        Args:
            model: The pricing model to use
            start_date: Start date
            maturity_or_end_date: Maturity tenor or explicit end date
            strike: Strike rate
            power: Power exponent for the rate
            cap_floor: 'Cap' or 'Floor'
            frequency_period: Payment frequency (optional)
            cpn_days_count: Coupon day count convention (optional)
            reset_gap: Reset gap in days (optional)
            pay_gap: Payment gap in days (optional)
            option_notional: Notional amount (optional)
            reset_timing: Reset timing convention (optional)
            index_term: Underlying index tenor (optional)
            index_days_count: Index day count convention (optional)
            convexity_adjustment_method: Convexity adjustment method (optional)
            report_configuration: Reporting configuration (optional)
            sensibility_bump_value: Sensitivity bump for risk calculations (optional)

        Returns:
            FunctionCall representing CapPower(...)
        """
        args = [model, start_date, maturity_or_end_date, strike, power, cap_floor]
        if frequency_period is not None:
            args.append(frequency_period)
        if cpn_days_count is not None:
            args.append(cpn_days_count)
        if reset_gap is not None:
            args.append(reset_gap)
        if pay_gap is not None:
            args.append(pay_gap)
        if option_notional is not None:
            args.append(option_notional)
        if reset_timing is not None:
            args.append(reset_timing)
        if index_term is not None:
            args.append(index_term)
        if index_days_count is not None:
            args.append(index_days_count)
        if convexity_adjustment_method is not None:
            args.append(convexity_adjustment_method)
        if report_configuration is not None:
            args.append(report_configuration)
        if sensibility_bump_value is not None:
            args.append(sensibility_bump_value)
        return FunctionCall("CapPower", *args)

    @staticmethod
    def cap_digital(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        cap_floor: Union[str, float, FormulaExpression],
        frequency_period: Union[Frequency, str] = None,
        cpn_days_count: Union[DayCount, str] = None,
        reset_gap: Union[str, float, FormulaExpression] = None,
        pay_gap: Union[str, float, FormulaExpression] = None,
        option_notional: Union[str, float, FormulaExpression] = None,
        reset_timing: Union[ResetTiming, str] = None,
        index_term: Union[str, float, FormulaExpression] = None,
        index_days_count: Union[DayCount, str] = None,
        strike_epsilon: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        CapDigital - Prices a digital cap/floor

        PIT Syntax: CapDigital( Model, Start Date, Maturity or End Date, Strike, Cap/Floor, [Frequency period], [Cpn Days count], [Reset Gap], [Pay Gap], [Option's notional], [Reset Timing], [Index Term], [Index Days count], [Strike epsilon] )

        Args:
            model: The pricing model to use
            start_date: Start date
            maturity_or_end_date: Maturity tenor or explicit end date
            strike: Strike rate
            cap_floor: 'Cap' or 'Floor'
            frequency_period: Payment frequency (optional)
            cpn_days_count: Coupon day count convention (optional)
            reset_gap: Reset gap in days (optional)
            pay_gap: Payment gap in days (optional)
            option_notional: Notional amount (optional)
            reset_timing: Reset timing convention (optional)
            index_term: Underlying index tenor (optional)
            index_days_count: Index day count convention (optional)
            strike_epsilon: Strike epsilon for digital payoff smoothing (optional)

        Returns:
            FunctionCall representing CapDigital(...)
        """
        args = [model, start_date, maturity_or_end_date, strike, cap_floor]
        if frequency_period is not None:
            args.append(frequency_period)
        if cpn_days_count is not None:
            args.append(cpn_days_count)
        if reset_gap is not None:
            args.append(reset_gap)
        if pay_gap is not None:
            args.append(pay_gap)
        if option_notional is not None:
            args.append(option_notional)
        if reset_timing is not None:
            args.append(reset_timing)
        if index_term is not None:
            args.append(index_term)
        if index_days_count is not None:
            args.append(index_days_count)
        if strike_epsilon is not None:
            args.append(strike_epsilon)
        return FunctionCall("CapDigital", *args)

    @staticmethod
    def caplet(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        cap_floor: Union[str, float, FormulaExpression],
        cpn_days_count: Union[DayCount, str] = None,
        reset_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        pay_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        option_notional: Union[str, float, FormulaExpression] = None,
        reset_timing: Union[ResetTiming, str] = None,
        index_term: Union[str, float, FormulaExpression] = None,
        index_days_count: Union[DayCount, str] = None,
    ) -> "FunctionCall":
        """
        Caplet - Prices a single-period cap or floor (caplet/floorlet)

        PIT Syntax: Caplet( Currency, Start Date, Maturity or End Date, Strike, Cap/Floor, [Cpn Days count], [Reset Gap or Date], [Pay Gap or Date], [Option's notional], [Reset Timing], [Index Term], [Index Days count] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date
            maturity_or_end_date: Maturity tenor or explicit end date
            strike: Strike rate
            cap_floor: 'Cap' or 'Floor'
            cpn_days_count: Coupon day count convention (optional)
            reset_gap_or_date: Reset gap in days or explicit reset date (optional)
            pay_gap_or_date: Payment gap in days or explicit payment date (optional)
            option_notional: Notional amount (optional)
            reset_timing: Reset timing convention (optional)
            index_term: Underlying index tenor (optional)
            index_days_count: Index day count convention (optional)

        Returns:
            FunctionCall representing Caplet(...)
        """
        args = [currency, start_date, maturity_or_end_date, strike, cap_floor]
        if cpn_days_count is not None:
            args.append(cpn_days_count)
        if reset_gap_or_date is not None:
            args.append(reset_gap_or_date)
        if pay_gap_or_date is not None:
            args.append(pay_gap_or_date)
        if option_notional is not None:
            args.append(option_notional)
        if reset_timing is not None:
            args.append(reset_timing)
        if index_term is not None:
            args.append(index_term)
        if index_days_count is not None:
            args.append(index_days_count)
        return FunctionCall("Caplet", *args)

    @staticmethod
    def digital(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        cap_floor: Union[str, float, FormulaExpression],
        cpn_days_count: Union[DayCount, str] = None,
        reset_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        pay_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        option_notional: Union[str, float, FormulaExpression] = None,
        reset_timing: Union[ResetTiming, str] = None,
        index_term: Union[str, float, FormulaExpression] = None,
        index_days_count: Union[DayCount, str] = None,
        is_adjusted: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        Digital - Prices a single-period digital option on an interest rate

        PIT Syntax: Digital( Currency, Start Date, Maturity or End Date, Strike, Cap/Floor, [Cpn Days count], [Reset Gap or Date], [Pay Gap or Date], [Option's notional], [Reset Timing], [Index Term], [Index Days count], [Is adjusted] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date
            maturity_or_end_date: Maturity tenor or explicit end date
            strike: Strike rate
            cap_floor: 'Cap' or 'Floor'
            cpn_days_count: Coupon day count convention (optional)
            reset_gap_or_date: Reset gap in days or explicit reset date (optional)
            pay_gap_or_date: Payment gap in days or explicit payment date (optional)
            option_notional: Notional amount (optional)
            reset_timing: Reset timing convention (optional)
            index_term: Underlying index tenor (optional)
            index_days_count: Index day count convention (optional)
            is_adjusted: Whether rates are adjusted (optional)

        Returns:
            FunctionCall representing Digital(...)
        """
        args = [currency, start_date, maturity_or_end_date, strike, cap_floor]
        if cpn_days_count is not None:
            args.append(cpn_days_count)
        if reset_gap_or_date is not None:
            args.append(reset_gap_or_date)
        if pay_gap_or_date is not None:
            args.append(pay_gap_or_date)
        if option_notional is not None:
            args.append(option_notional)
        if reset_timing is not None:
            args.append(reset_timing)
        if index_term is not None:
            args.append(index_term)
        if index_days_count is not None:
            args.append(index_days_count)
        if is_adjusted is not None:
            args.append(is_adjusted)
        return FunctionCall("Digital", *args)

    @staticmethod
    def ir_index(
        model: Union[str, float, FormulaExpression],
        index: Index,
        start_date: Union[str, date, FormulaExpression],
        end_date_or_relative_maturity: Union[str, date, FormulaExpression],
        relative_payment_date: Union[str, date, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        IrIndex -

        PIT Syntax: IrIndex( Model, Index, Start Date, End Date or Relative Maturity, [Relative Payment Date], [RFR Lag Type], [Lag] )

        Args:
            model: The model to compute with
            index: The index which is observed: LIBOR, EURIBOR, RFR, CMS, etc. (use IndexType enum for auto-completion)
            start_date: Date on which the index starts
            end_date_or_relative_maturity: End Date or Tenor (with respect to the Start Date) of the index; a tenor is nb followed by d/w/m/y like 6m or 1y
            relative_payment_date: Payment (with respect to the Start Date) date of the index, which is a nb followed by d/w/m/y like 6m or 1y (optional)
            rfr_lag_type: Type of Lag to apply in RFR calculation, can be LOOKBACK, SHIFT, LOCKOUT or NONE (optional)
            lag: Lag (number of days) to apply according to the RFR Lag type (optional)

        Returns:
            FunctionCall representing IrIndex(...)
        """
        args = []
        args.append(model)
        args.append(index)
        args.append(start_date)
        args.append(end_date_or_relative_maturity)
        if relative_payment_date is not None:
            args.append(relative_payment_date)
        # if rfr_lag_type is not None:
        #     args.append(rfr_lag_type)
        # if lag is not None:
        #     args.append(lag)
        return FunctionCall("IrIndex", *args)

    @staticmethod
    def libor(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        days_count: Union[DayCount, str] = None,
        reset_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        pay_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        payment_timing: Union[PayTiming, str] = None,
    ) -> "FunctionCall":
        """
        Libor - Retrieves LIBOR forward rate (DEPRECATED - use RFR rates)

        PIT Syntax: Libor( Currency, Start Date, Maturity or End Date, [Days count], [Reset Gap or Date], [Pay Gap or Date], [Payment Timing] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date
            maturity_or_end_date: Maturity tenor (e.g., '3m', '6m') or explicit end date
            days_count: Day count convention (e.g., DayCount.ACTUAL_360) (optional)
            reset_gap_or_date: Reset gap in days or explicit reset date (optional)
            pay_gap_or_date: Payment gap in days or explicit payment date (optional)
            payment_timing: Payment timing convention (e.g., PayTiming.ARREARS) (optional)

        Returns:
            FunctionCall representing Libor(...)
        """
        args = [currency, start_date, maturity_or_end_date]
        if days_count is not None:
            args.append(days_count)
        if reset_gap_or_date is not None:
            args.append(reset_gap_or_date)
        if pay_gap_or_date is not None:
            args.append(pay_gap_or_date)
        if payment_timing is not None:
            args.append(payment_timing)
        return FunctionCall("Libor", *args)

    @staticmethod
    def price_to_yield(
        settlement_date: Union[str, date, FormulaExpression],
        issue_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        coupon: Union[str, float, FormulaExpression],
        price: Union[str, float, FormulaExpression],
        frequency_period: Union[Frequency, str] = "1Y",
        days_count: Union[DayCount, str] = "30/360",
        notional: Union[str, float, FormulaExpression] = "100",
        price_type: Union[str, float, FormulaExpression] = "Dirty",
    ) -> "FunctionCall":
        """
        PriceToYield - Price to yield.

        PIT Syntax: PriceToYield( Settlement Date, Issue Date, Tenor or End Date, Coupon, Price, [Frequency period], [Days count], [Notional], [Price Type] )

        Args:
            settlement_date: Settlement date
            issue_date: Issue date
            tenor_or_end_date: Tenor or End Date, a tenor is nb followed by d/w/m/y like 6m or 1y
            coupon: Coupon in real terms
            price: Price in real terms
            frequency_period: Coupon Frequency period = nb followed by d/w/m/y like 6m or 1y (optional)
            days_count: Coupon Days Count convention: ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)
            notional: Redemption Value in real terms (optional)
            price_type: Dirty or Clean Price (optional)

        Returns:
            FunctionCall representing PriceToYield(...)
        """
        args = []
        args.append(settlement_date)
        args.append(issue_date)
        args.append(tenor_or_end_date)
        args.append(coupon)
        args.append(price)
        if frequency_period is not None:
            args.append(frequency_period)
        if days_count is not None:
            args.append(days_count)
        if notional is not None:
            args.append(notional)
        if price_type is not None:
            args.append(price_type)
        return FunctionCall("PriceToYield", *args)

    @staticmethod
    def range_accrual(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        maturity_or_end_date: Union[str, date, FormulaExpression],
        index_1_tenor: Union[str, float, FormulaExpression],
        index_2_tenor: Union[str, float, FormulaExpression] = "NotProvided",
        barrier_down_value: Union[str, float, FormulaExpression] = "-1e20",
        barrier_up_value: Union[str, float, FormulaExpression] = "1e20",
        observation_frequency: Union[Frequency, str] = "Daily",
        index_1_gearing: Union[str, float, FormulaExpression] = "1",
        index_2_gearing: Union[str, float, FormulaExpression] = "-1",
        index_1_type: Union[str, float, FormulaExpression] = "CMS",
        index_2_type: Union[str, float, FormulaExpression] = "CMS",
        secondary_observation_frequency: Union[Frequency, str] = "NotProvided",
        fraction_or_number_of_days: Union[str, float, FormulaExpression] = "Price",
        convexity_adjustment_method: Union[DateRule, str] = "DEFAULT",
    ) -> "FunctionCall":
        """
        RangeAccrual - For instance, if you want to compute the number of days where the spread a*CMS30Y-b*CMS2Y is in the interval [L,U], you can use this keyword:RangeAccrual( EUR, StartDate, EndDate,30Y, 2Y,L,U,Daily,a,...

        PIT Syntax: RangeAccrual( Model, Start Date, Maturity or End Date, Index 1 Tenor, [Index 2 Tenor], [Barrier Down Value], [Barrier Up Value], [Observation Frequency], [Index 1 Gearing], [Index 2 Gearing], [Index 1 Type], [Index 2 Type], [Secondary Observation Frequency ], [Fraction or number of Days], [Convexity Adjustment Method] )

        Args:
            model: The model to compute with
            start_date: Start date of the rangeAccrual schedule
            maturity_or_end_date: Tenor or End Date of the corridor schedule,                                                                                         a tenor is nb followed by d/w/m/y like 6m or 1y
            index_1_tenor: Tenor of 1st index
            index_2_tenor: Tenor of 2nd index (optional)
            barrier_down_value: Value of the barrier down (optional)
            barrier_up_value: Value of the barrier up (optional)
            observation_frequency: Observation Frequency (A/S/Q/M/W/D/B) (optional)
            index_1_gearing: Gearing(s) of 1st index (optional)
            index_2_gearing: Gearing(s) of 2nd index (optional)
            index_1_type: Type of the 1st index (LIBOR/CMS) (optional)
            index_2_type: Type of the 2nd index (LIBOR/CMS) (optional)
            secondary_observation_frequency: Secondary Observation Frequency (A/S/Q/M/W/D/B) (optional)
            fraction_or_number_of_days: Returns the fraction or the number of days (optional)
            convexity_adjustment_method: Choose between BLACK, HAGAN, REPLICATION (optional)

        Returns:
            FunctionCall representing RangeAccrual(...)
        """
        args = []
        args.append(model)
        args.append(start_date)
        args.append(maturity_or_end_date)
        args.append(index_1_tenor)
        if index_2_tenor is not None:
            args.append(index_2_tenor)
        if barrier_down_value is not None:
            args.append(barrier_down_value)
        if barrier_up_value is not None:
            args.append(barrier_up_value)
        if observation_frequency is not None:
            args.append(observation_frequency)
        if index_1_gearing is not None:
            args.append(index_1_gearing)
        if index_2_gearing is not None:
            args.append(index_2_gearing)
        if index_1_type is not None:
            args.append(index_1_type)
        if index_2_type is not None:
            args.append(index_2_type)
        if secondary_observation_frequency is not None:
            args.append(secondary_observation_frequency)
        if fraction_or_number_of_days is not None:
            args.append(fraction_or_number_of_days)
        if convexity_adjustment_method is not None:
            args.append(convexity_adjustment_method)
        return FunctionCall("RangeAccrual", *args)

    @staticmethod
    def short_rate(model: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        ShortRate - This keyword retrieves the short rate of a model at a given time.The only argument of this keyword is the model name.If the model is not a short rate model (for instance Libor Market Model), the short...

        PIT Syntax: ShortRate( Model )

        Args:
            model: The model to compute with

        Returns:
            FunctionCall representing ShortRate(...)
        """
        return FunctionCall("ShortRate", model)

    @staticmethod
    def spread_option(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        pay_date: Union[str, date, FormulaExpression],
        index_1_tenor: Union[str, float, FormulaExpression],
        index_2_tenor: Union[str, float, FormulaExpression] = None,
        index_1_gearing: Union[str, float, FormulaExpression] = None,
        index_2_gearing: Union[str, float, FormulaExpression] = None,
        strike: Union[str, float, FormulaExpression] = None,
        cap_floor: Union[str, float, FormulaExpression] = None,
        index_1_type: Union[str, float, FormulaExpression] = None,
        index_2_type: Union[str, float, FormulaExpression] = None,
        convexity_adjustment_method: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        SpreadOption - Prices an option on the spread between two interest rate indices

        PIT Syntax: SpreadOption( Model, Start Date, Pay Date, Index 1 Tenor, [Index 2 Tenor], [Index 1 Gearing], [Index 2 Gearing], Strike, Cap/Floor, [Index 1 Type], [Index 2 Type], [Convexity Adjustment Method] )

        Args:
            model: The pricing model to use
            start_date: Start date (observation date)
            pay_date: Payment date
            index_1_tenor: Tenor of first index (e.g., '30y')
            index_2_tenor: Tenor of second index (e.g., '2y') (optional)
            index_1_gearing: Gearing/multiplier for first index (optional)
            index_2_gearing: Gearing/multiplier for second index (optional)
            strike: Strike level for the spread (optional)
            cap_floor: 'Cap' or 'Floor' (optional)
            index_1_type: Type of first index (e.g., 'CMS', 'LIBOR') (optional)
            index_2_type: Type of second index (e.g., 'CMS', 'LIBOR') (optional)
            convexity_adjustment_method: Convexity adjustment method (optional)

        Returns:
            FunctionCall representing SpreadOption(...)
        """
        args = [model, start_date, pay_date, index_1_tenor]
        if index_2_tenor is not None:
            args.append(index_2_tenor)
        if index_1_gearing is not None:
            args.append(index_1_gearing)
        if index_2_gearing is not None:
            args.append(index_2_gearing)
        if strike is not None:
            args.append(strike)
        if cap_floor is not None:
            args.append(cap_floor)
        if index_1_type is not None:
            args.append(index_1_type)
        if index_2_type is not None:
            args.append(index_2_type)
        if convexity_adjustment_method is not None:
            args.append(convexity_adjustment_method)
        return FunctionCall("SpreadOption", *args)

    @staticmethod
    def swap(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        fixed_rate: Union[str, float, FormulaExpression],
        pay_rec: Union[str, float, FormulaExpression],
        fixed_frequency_period: Union[Frequency, str] = None,
        fixed_days_count: Union[DayCount, str] = None,
        floating_frequency_period: Union[Frequency, str] = None,
        floating_days_count: Union[DayCount, str] = None,
        margin: Union[str, float, FormulaExpression] = None,
        swap_notional: Union[str, float, FormulaExpression] = None,
        report_configuration: Union[str, float, FormulaExpression] = None,
        sensibility_bump_value: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        Swap - Prices an interest rate swap

        PIT Syntax: Swap( Currency, Start Date, Tenor or End Date, Fixed Rate, Pay/Rec, [Fixed Frequency period], [Fixed Days count], [Floating Frequency period], [Floating Days count], [Margin], [Swap's notional], [Report Configuration], [Sensibility bump value] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date of the swap
            tenor_or_end_date: Tenor (e.g., '5y', '10y') or explicit end date
            fixed_rate: Fixed rate of the swap
            pay_rec: Direction - 'Pay' (pay fixed) or 'Rec' (receive fixed)
            fixed_frequency_period: Fixed leg payment frequency (optional)
            fixed_days_count: Fixed leg day count convention (optional)
            floating_frequency_period: Floating leg payment frequency (optional)
            floating_days_count: Floating leg day count convention (optional)
            margin: Spread over floating rate (optional)
            swap_notional: Notional amount (optional)
            report_configuration: Reporting configuration (optional)
            sensibility_bump_value: Sensitivity bump for risk calculations (optional)

        Returns:
            FunctionCall representing Swap(...)
        """
        args = [currency, start_date, tenor_or_end_date, fixed_rate, pay_rec]
        if fixed_frequency_period is not None:
            args.append(fixed_frequency_period)
        if fixed_days_count is not None:
            args.append(fixed_days_count)
        if floating_frequency_period is not None:
            args.append(floating_frequency_period)
        if floating_days_count is not None:
            args.append(floating_days_count)
        if margin is not None:
            args.append(margin)
        if swap_notional is not None:
            args.append(swap_notional)
        if report_configuration is not None:
            args.append(report_configuration)
        if sensibility_bump_value is not None:
            args.append(sensibility_bump_value)
        return FunctionCall("Swap", *args)

    @staticmethod
    def swap_rate(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        fixed_frequency_period: Union[Frequency, str] = None,
        fixed_days_count: Union[DayCount, str] = None,
        floating_frequency_period: Union[Frequency, str] = None,
        floating_days_count: Union[DayCount, str] = None,
        margin: Union[str, float, FormulaExpression] = None,
        use_convexity: Union[str, float, FormulaExpression] = None,
        convexity_adjustment_method: Union[str, float, FormulaExpression] = None,
        payment_date: Union[str, date, FormulaExpression] = None,
        integration_limit: Union[str, float, FormulaExpression] = None,
        integration_lower_bound: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        SwapRate - Computes the par swap rate

        PIT Syntax: SwapRate( Currency, Start Date, Tenor or End Date, [Fixed Frequency period], [Fixed Days count], [Floating Frequency period], [Floating Days count], [Margin], [Use Convexity], [Convexity Adjustment Method], [Payment Date], [Integration limit], [Integration lower bound] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date
            tenor_or_end_date: Tenor (e.g., '5y', '10y') or explicit end date
            fixed_frequency_period: Fixed leg payment frequency (optional)
            fixed_days_count: Fixed leg day count convention (optional)
            floating_frequency_period: Floating leg payment frequency (optional)
            floating_days_count: Floating leg day count convention (optional)
            margin: Spread over floating rate (optional)
            use_convexity: Whether to apply convexity adjustment (optional)
            convexity_adjustment_method: Method for convexity adjustment (optional)
            payment_date: Payment date for the rate (optional)
            integration_limit: Integration limit for convexity calculation (optional)
            integration_lower_bound: Lower bound for integration (optional)

        Returns:
            FunctionCall representing SwapRate(...)
        """
        args = [currency, start_date, tenor_or_end_date]
        if fixed_frequency_period is not None:
            args.append(fixed_frequency_period)
        if fixed_days_count is not None:
            args.append(fixed_days_count)
        if floating_frequency_period is not None:
            args.append(floating_frequency_period)
        if floating_days_count is not None:
            args.append(floating_days_count)
        if margin is not None:
            args.append(margin)
        if use_convexity is not None:
            args.append(use_convexity)
        if convexity_adjustment_method is not None:
            args.append(convexity_adjustment_method)
        if payment_date is not None:
            args.append(payment_date)
        if integration_limit is not None:
            args.append(integration_limit)
        if integration_lower_bound is not None:
            args.append(integration_lower_bound)
        return FunctionCall("SwapRate", *args)

    @staticmethod
    def rfr__swap_rate(
        currency: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        fixed_frequency_period: Union[Frequency, str] = None,
        fixed_days_count: Union[DayCount, str] = None,
        floating_frequency_period: Union[Frequency, str] = None,
        floating_days_count: Union[DayCount, str] = None,
        margin: Union[str, float, FormulaExpression] = None,
        use_convexity: Union[str, float, FormulaExpression] = None,
        convexity_adjustment_method: Union[str, float, FormulaExpression] = None,
        payment_date: Union[str, date, FormulaExpression] = None,
        integration_limit: Union[str, float, FormulaExpression] = None,
        integration_lower_bound: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        RFR SwapRate - Computes RFR-based swap rates (SOFR, SONIA, ESTR)

        PIT Syntax: CMSRate( Currency, Start Date, Tenor or End Date, [Fixed Frequency period], [Fixed Days count], [Floating Frequency period], [Floating Days count], [Margin], [Use Convexity], [Convexity Adjustment Method], [Payment Date], [Integration limit], [Integration lower bound] )

        Args:
            currency: Currency code (e.g., 'USD', 'EUR')
            start_date: Start date
            tenor_or_end_date: Tenor (e.g., '5y', '10y') or explicit end date
            fixed_frequency_period: Fixed leg payment frequency (optional)
            fixed_days_count: Fixed leg day count convention (optional)
            floating_frequency_period: Floating leg payment frequency (optional)
            floating_days_count: Floating leg day count convention (optional)
            margin: Spread over floating rate (optional)
            use_convexity: Whether to apply convexity adjustment (optional)
            convexity_adjustment_method: Method for convexity adjustment (optional)
            payment_date: Payment date for the rate (optional)
            integration_limit: Integration limit for convexity calculation (optional)
            integration_lower_bound: Lower bound for integration (optional)

        Returns:
            FunctionCall representing RFR SwapRate(...)
        """
        args = [currency, start_date, tenor_or_end_date]
        if fixed_frequency_period is not None:
            args.append(fixed_frequency_period)
        if fixed_days_count is not None:
            args.append(fixed_days_count)
        if floating_frequency_period is not None:
            args.append(floating_frequency_period)
        if floating_days_count is not None:
            args.append(floating_days_count)
        if margin is not None:
            args.append(margin)
        if use_convexity is not None:
            args.append(use_convexity)
        if convexity_adjustment_method is not None:
            args.append(convexity_adjustment_method)
        if payment_date is not None:
            args.append(payment_date)
        if integration_limit is not None:
            args.append(integration_limit)
        if integration_lower_bound is not None:
            args.append(integration_lower_bound)
        return FunctionCall("RFR SwapRate", *args)

    @staticmethod
    def swaption(
        model: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        pay_rec: Union[str, float, FormulaExpression],
        fix_freq_period: Union[Frequency, str] = None,
        fix_days_count: Union[DayCount, str] = None,
        float_freq_period: Union[Frequency, str] = None,
        float_days_count: Union[DayCount, str] = None,
        reset_gap_or_date: Union[str, float, date, FormulaExpression] = None,
        option_notional: Union[str, float, FormulaExpression] = None,
        report_configuration: Union[str, float, FormulaExpression] = None,
        sensibility_bump_value: Union[str, float, FormulaExpression] = None,
        settlement_type: Union[str, float, FormulaExpression] = None,
        fixed_leg_calendar: Union[Calendar, str] = None,
        float_leg_calendar: Union[Calendar, str] = None,
    ) -> "FunctionCall":
        """
        Swaption - Prices an option to enter into an interest rate swap

        PIT Syntax: Swaption( Model, Start Date, Tenor or End Date, Strike, Pay/rec, [Fix Freq Period], [Fix Days count], [Float Freq Period], [Float Days count], [Reset Gap or Date], [Option's notional], [Report Configuration], [Sensibility bump value], [Settlement Type], [Fixed Leg Calendar], [Float Leg Calendar] )

        Args:
            model: The pricing model to use
            start_date: Option expiry / swap start date
            tenor_or_end_date: Swap tenor or explicit end date
            strike: Strike rate
            pay_rec: 'Pay' (pay fixed) or 'Rec' (receive fixed)
            fix_freq_period: Fixed leg payment frequency (optional)
            fix_days_count: Fixed leg day count convention (optional)
            float_freq_period: Floating leg payment frequency (optional)
            float_days_count: Floating leg day count convention (optional)
            reset_gap_or_date: Reset gap in days or explicit reset date (optional)
            option_notional: Notional amount (optional)
            report_configuration: Reporting configuration (optional)
            sensibility_bump_value: Sensitivity bump for risk calculations (optional)
            settlement_type: Settlement type (e.g., 'Cash', 'Physical') (optional)
            fixed_leg_calendar: Fixed leg calendar (optional)
            float_leg_calendar: Floating leg calendar (optional)

        Returns:
            FunctionCall representing Swaption(...)
        """
        args = [model, start_date, tenor_or_end_date, strike, pay_rec]
        if fix_freq_period is not None:
            args.append(fix_freq_period)
        if fix_days_count is not None:
            args.append(fix_days_count)
        if float_freq_period is not None:
            args.append(float_freq_period)
        if float_days_count is not None:
            args.append(float_days_count)
        if reset_gap_or_date is not None:
            args.append(reset_gap_or_date)
        if option_notional is not None:
            args.append(option_notional)
        if report_configuration is not None:
            args.append(report_configuration)
        if sensibility_bump_value is not None:
            args.append(sensibility_bump_value)
        if settlement_type is not None:
            args.append(settlement_type)
        if fixed_leg_calendar is not None:
            args.append(fixed_leg_calendar)
        if float_leg_calendar is not None:
            args.append(float_leg_calendar)
        return FunctionCall("Swaption", *args)

    @staticmethod
    def yield_to_price(
        settlement_date: Union[str, date, FormulaExpression],
        issue_date: Union[str, date, FormulaExpression],
        tenor_or_end_date: Union[str, date, FormulaExpression],
        coupon: Union[str, float, FormulaExpression],
        yield_: Union[str, float, FormulaExpression],
        frequency_period: Union[Frequency, str] = "1Y",
        days_count: Union[DayCount, str] = "30/360",
        notional: Union[str, float, FormulaExpression] = "100",
        price_type: Union[str, float, FormulaExpression] = "Dirty",
    ) -> "FunctionCall":
        """
        YieldToPrice - Yield To Price.

        PIT Syntax: YieldToPrice( Settlement Date, Issue Date, Tenor or End Date, Coupon, Yield, [Frequency period], [Days count], [Notional], [Price Type] )

        Args:
            settlement_date: Settlement date
            issue_date: Issue date
            tenor_or_end_date: Tenor or End Date, a tenor is nb followed by d/w/m/y like 6m or 1y
            coupon: Coupon in real terms
            yield_: Yield in real terms
            frequency_period: Coupon Frequency period = nb followed by d/w/m/y like 6m or 1y (optional)
            days_count: Coupon Days Count convention: ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)
            notional: Redemption Value in real terms (optional)
            price_type: Dirty or Clean Price (optional)

        Returns:
            FunctionCall representing YieldToPrice(...)
        """
        args = []
        args.append(settlement_date)
        args.append(issue_date)
        args.append(tenor_or_end_date)
        args.append(coupon)
        args.append(yield_)
        if frequency_period is not None:
            args.append(frequency_period)
        if days_count is not None:
            args.append(days_count)
        if notional is not None:
            args.append(notional)
        if price_type is not None:
            args.append(price_type)
        return FunctionCall("YieldToPrice", *args)

    @staticmethod
    def cpi(
        inflationindexname: Union[str, float, FormulaExpression],
        cpifixingdate: Union[str, date, FormulaExpression],
        publicationperiod: Union[str, float, FormulaExpression] = "3M",
        daily_interpolation_type: Union[str, float, FormulaExpression] = "DEFAULT_PER_INDEX",
        reset_lag: Union[str, float, FormulaExpression] = "0M",
    ) -> "FunctionCall":
        """
        CPI - This keyword computes the Consumer Price Index based on two compulsory arguments: the name of the inflation model and the fixing date. By default, the publication date is set to be 3 months after the ...

        PIT Syntax: CPI( InflationIndexName , CPIFixingDate , [PublicationPeriod ], [Daily Interpolation Type], [Reset Lag ] )

        Args:
            inflationindexname: Name of the inflation index.             In the multi asset model name map             object, the user should provide for             this inflation index name a corresponding             inflation model
            cpifixingdate: This is the fixing date of the CPI. For instance,             if the inflation index is corresponding to the number             of the month of MARCH and is published 3 months later,              the CPI Fixing Date is MARCH, while the publication date is in JUNE
            publicationperiod: period of time between the fixing date and the             publication date. Standard market practice is 3 months. (optional)
            daily_interpolation_type: Type of daily interpolation. Possible choices: CPILINEAR, STEPWISESTART, STEPWISEMID, STEPWISEEND,    STEPWISE, ZCLINEAR, ZCCTFWD. See technical on inflation convention (optional)
            reset_lag: Reset Lag of the CPI (optional)

        Returns:
            FunctionCall representing CPI(...)
        """
        args = []
        args.append(inflationindexname)
        args.append(cpifixingdate)
        if publicationperiod is not None:
            args.append(publicationperiod)
        if daily_interpolation_type is not None:
            args.append(daily_interpolation_type)
        if reset_lag is not None:
            args.append(reset_lag)
        return FunctionCall("CPI", *args)

    @staticmethod
    def inf_swap_rate(
        currency: Union[str, float, FormulaExpression],
        infmodel: Union[str, float, FormulaExpression],
        yoy_oat: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        end_date: Union[str, date, FormulaExpression],
        coupon: Union[str, float, FormulaExpression] = "0.03",
        spread: Union[str, float, FormulaExpression] = "0",
        floatings_reset_gap: Union[str, float, FormulaExpression] = "1",
        floatings_payment_gap: Union[str, float, FormulaExpression] = "1",
        floating_frequency_period: Union[Frequency, str] = "DEFAULT_PER_CURRENCY",
        floating_days_count: Union[DayCount, str] = "DEFAULT_PER_CURRENCY",
        fixed_frequency_period: Union[Frequency, str] = "DEFAULT_PER_CURRENCY",
        fixed_days_count: Union[DayCount, str] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        InfSwapRate - An inflation swap has an IR leg and an inflation leg. The IR leg pays a fixed rate while the inflation leg pays the inflation rate (for instance Year-on-Year inflation). This keyword returns the rate ...

        PIT Syntax: InfSwapRate( Currency , InfModel , YoY/OAT , Start Date , End Date , [Coupon ], [Spread ], [Floating's Reset Gap ], [Floating's Payment Gap ], [Floating Frequency period ], [Floating Days count ], [Fixed Frequency period ], [Fixed Days count ] )

        Args:
            currency: The IR model to compute the the SwapRate with
            infmodel: The Inf model to compute the SwapRate with
            yoy_oat: infSwap's type YoY or OAT
            start_date: Start Date of the swap
            end_date: End Date of the swap
            coupon: Coupon of the OAT type (optional)
            spread: Spread (optional)
            floatings_reset_gap: Reset Gap (in days) of the floating (optional)
            floatings_payment_gap: Payment Gap (in days) of the floating (optional)
            floating_frequency_period: Floating Leg period = nb followed by d/w/m/y like 6m or 1y (optional)
            floating_days_count: convention ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)
            fixed_frequency_period: Fixed Leg period = nb followed by d/w/m/y like 6m or 1y (optional)
            fixed_days_count: convention ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)

        Returns:
            FunctionCall representing InfSwapRate(...)
        """
        args = []
        args.append(currency)
        args.append(infmodel)
        args.append(yoy_oat)
        args.append(start_date)
        args.append(end_date)
        if coupon is not None:
            args.append(coupon)
        if spread is not None:
            args.append(spread)
        if floatings_reset_gap is not None:
            args.append(floatings_reset_gap)
        if floatings_payment_gap is not None:
            args.append(floatings_payment_gap)
        if floating_frequency_period is not None:
            args.append(floating_frequency_period)
        if floating_days_count is not None:
            args.append(floating_days_count)
        if fixed_frequency_period is not None:
            args.append(fixed_frequency_period)
        if fixed_days_count is not None:
            args.append(fixed_days_count)
        return FunctionCall("InfSwapRate", *args)

    @staticmethod
    def inf_swap(
        currency: Union[str, float, FormulaExpression],
        infmodel: Union[str, float, FormulaExpression],
        yoy_oat: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        end_date: Union[str, date, FormulaExpression],
        strike: Union[str, float, FormulaExpression] = "0.03",
        coupon: Union[str, float, FormulaExpression] = "0.03",
        spread: Union[str, float, FormulaExpression] = "0",
        floatings_reset_gap: Union[str, float, FormulaExpression] = "0",
        floatings_payment_gap: Union[str, float, FormulaExpression] = "0",
        floating_frequency_period: Union[Frequency, str] = "DEFAULT_PER_CURRENCY",
        floating_days_count: Union[DayCount, str] = "DEFAULT_PER_CURRENCY",
        fixed_frequency_period: Union[Frequency, str] = "DEFAULT_PER_CURRENCY",
        fixed_days_count: Union[DayCount, str] = "DEFAULT_PER_CURRENCY",
    ) -> "FunctionCall":
        """
        InfSwap - An inflation swap has an IR leg and an inflation leg. The IR leg pays a fixed rate while the inflation leg pays the inflation rate (for instance Year-on-Year inflation). This keyword returns the price...

        PIT Syntax: InfSwap( Currency , InfModel , YoY/OAT , Start Date , End Date , [Strike ], [Coupon ], [Spread ], [Floating's Reset Gap ], [Floating's Payment Gap ], [Floating Frequency period ], [Floating Days count ], [Fixed Frequency period ], [Fixed Days count ] )

        Args:
            currency: The IR model to compute the the SwapRate with
            infmodel: The Inf model to compute the SwapRate with
            yoy_oat: infSwap's type YoY or OAT
            start_date: Start Date of the swap
            end_date: End Date of the swap
            strike: Swap's Strike in real terms (optional)
            coupon: Coupon of the OAT type (optional)
            spread: Spread (optional)
            floatings_reset_gap: Reset Gap (in days) of the floating (optional)
            floatings_payment_gap: Payment Gap (in days) of the floating (optional)
            floating_frequency_period: Floating Leg period = nb followed by d/w/m/y like 6m or 1y (optional)
            floating_days_count: convention ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)
            fixed_frequency_period: Fixed Leg period = nb followed by d/w/m/y like 6m or 1y (optional)
            fixed_days_count: convention ACTUAL, A365, A360, 30/360, ACTREAL, ACT29, ISMA, NOBASE (optional)

        Returns:
            FunctionCall representing InfSwap(...)
        """
        args = []
        args.append(currency)
        args.append(infmodel)
        args.append(yoy_oat)
        args.append(start_date)
        args.append(end_date)
        if strike is not None:
            args.append(strike)
        if coupon is not None:
            args.append(coupon)
        if spread is not None:
            args.append(spread)
        if floatings_reset_gap is not None:
            args.append(floatings_reset_gap)
        if floatings_payment_gap is not None:
            args.append(floatings_payment_gap)
        if floating_frequency_period is not None:
            args.append(floating_frequency_period)
        if floating_days_count is not None:
            args.append(floating_days_count)
        if fixed_frequency_period is not None:
            args.append(fixed_frequency_period)
        if fixed_days_count is not None:
            args.append(fixed_days_count)
        return FunctionCall("InfSwap", *args)

    @staticmethod
    def la_rate(
        inflationindexname: Union[str, float, FormulaExpression],
        revisiondate: Union[str, date, FormulaExpression],
        method: Union[str, float, FormulaExpression] = "Formula",
        rounding: Union[str, float, FormulaExpression] = "0.0025",
    ) -> "FunctionCall":
        """
        LARate - This keyword computes the rate of the Livret A. This rate is equal to:  LARate = Round(Max(0.5*Inf+0.25*(AvgEONIA+AvgEUR3M),Inf+0.25\%))  where rounding is made at the nearest 0.25\%, Inf is the an...

        PIT Syntax: LARate( InflationIndexName, RevisionDate, [Method], [Rounding] )

        Args:
            inflationindexname: Name of the inflation index.
            revisiondate: Date when the rate is computed.
            method: Method to be used to compute the Livret A rate (optional)
            rounding: Precision of the rate (0.25\%,0.5\%, ...) (optional)

        Returns:
            FunctionCall representing LARate(...)
        """
        args = []
        args.append(inflationindexname)
        args.append(revisiondate)
        if method is not None:
            args.append(method)
        if rounding is not None:
            args.append(rounding)
        return FunctionCall("LARate", *args)

    @staticmethod
    def alive(life_insurance_model: Union[str, float, FormulaExpression]) -> "FunctionCall":
        """
        Alive - Returns the probability   that the policyholder is still alive at a given time.

        PIT Syntax: Alive( Life Insurance model )

        Args:
            life_insurance_model: name of the life insurance model.

        Returns:
            FunctionCall representing Alive(...)
        """
        return FunctionCall("Alive", life_insurance_model)

    @staticmethod
    def mortality_rate(
        life_insurance_model: Union[str, float, FormulaExpression],
        age: Union[str, float, FormulaExpression],
        sex: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        MortalityRate - Returns the mortality rate                         of a specific population.

        PIT Syntax: MortalityRate( Life Insurance model, age, sex )

        Args:
            life_insurance_model: name of the life insurance model.
            age: age of the targeted population.
            sex: sex of the population.

        Returns:
            FunctionCall representing MortalityRate(...)
        """
        return FunctionCall("MortalityRate", life_insurance_model, age, sex)

    @staticmethod
    def lapse(
        life_insurance_model: Union[str, float, FormulaExpression],
        lapse_criterion: Union[str, float, FormulaExpression],
        lapse_fee: Union[str, float, FormulaExpression],
    ) -> "FunctionCall":
        """
        Lapse - Returns the payoff value after taking into account the lapse event. This keyword takes 3 compulsory arguments : the model name, the dynamic lapse criterion value and the value received in case of laps...

        PIT Syntax:

        Args:
            life_insurance_model: name of the life insurance model.
            lapse_criterion: criterion that motivates the lapse decision. A typical example of such criterion is contract moneyness.
            lapse_fee: compensation amount to be paid if the policyholder decides to end the contract.

        Returns:
            FunctionCall representing Lapse(...)
        """
        return FunctionCall("Lapse", life_insurance_model, lapse_criterion, lapse_fee)

    @staticmethod
    def withdrawal_rate(
        lifeinsurance_model: Union[str, float, FormulaExpression], criterion: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        WithdrawalRate - Returns the withdrawal rate of the policyholder. This keyword takes 2 compulsory arguments : the model name and the dynamic withdrawal criterion value. Then, the withdrawal rate surface is interpolate...

        PIT Syntax: WithdrawalRate( LifeInsurance model, Criterion )

        Args:
            lifeinsurance_model: name of the life insurance model.
            criterion: factor that influences the decision (for instance, account value).

        Returns:
            FunctionCall representing WithdrawalRate(...)
        """
        return FunctionCall("WithdrawalRate", lifeinsurance_model, criterion)

    @staticmethod
    def lapse_rate(
        lifeinsurance_model: Union[str, float, FormulaExpression], criterion: Union[str, float, FormulaExpression]
    ) -> "FunctionCall":
        """
        LapseRate - Returns the probability that the policyholder lapses the contract. This keyword takes 2 compulsory arguments : the model name and the dynamic lapse criterion value. Then, the lapse rate surface is int...

        PIT Syntax: LapseRate( LifeInsurance model, Criterion )

        Args:
            lifeinsurance_model: name of the life insurance model.
            criterion: factor that influences the decision (for instance, account value).

        Returns:
            FunctionCall representing LapseRate(...)
        """
        return FunctionCall("LapseRate", lifeinsurance_model, criterion)

    @staticmethod
    def life_annuity_rate(
        life_insurance_model: Union[str, float, FormulaExpression],
        annuity_start_date: Union[str, date, FormulaExpression],
        annuity_maturity: Union[str, float, FormulaExpression],
        annuity_frequency: Union[Frequency, str] = "1Y",
    ) -> "FunctionCall":
        """
        LifeAnnuityRate - Returns the rate of a life annuity. A life annuity works pretty similar to standard annuities except that we must take into account survival probabilities. Let consider an annuity that last from $T_0$...

        PIT Syntax: LifeAnnuityRate( Life Insurance model, Annuity start date, Annuity maturity, [Annuity frequency] )

        Args:
            life_insurance_model: name of the life insurance model.
            annuity_start_date: start date of the annuity.
            annuity_maturity: maturity of the life annuity. If maturity is zero, this means that the life             annuity is truly for life.
            annuity_frequency: payment frequency of the life annuity. (optional)

        Returns:
            FunctionCall representing LifeAnnuityRate(...)
        """
        args = []
        args.append(life_insurance_model)
        args.append(annuity_start_date)
        args.append(annuity_maturity)
        if annuity_frequency is not None:
            args.append(annuity_frequency)
        return FunctionCall("LifeAnnuityRate", *args)

    @staticmethod
    def scheduled_principal(
        model: Union[str, float, FormulaExpression],
        wam: Union[str, float, FormulaExpression],
        coupon: Union[str, float, FormulaExpression],
        frequency: Union[Frequency, str],
        balance: Union[str, float, FormulaExpression] = "1",
    ) -> "FunctionCall":
        """
        ScheduledPrincipal - MBS ScheduledPrincipal

        PIT Syntax: ScheduledPrincipal( Model , Wam , Coupon , [Balance ], Frequency )

        Args:
            model: The model to compute the ScheduledPrincipal on
            wam: MBS Weighted Average Maturity
            coupon: MBS coupon
            frequency: MBS frequency
            balance: MBS balance (optional)

        Returns:
            FunctionCall representing ScheduledPrincipal(...)
        """
        args = []
        args.append(model)
        args.append(wam)
        args.append(coupon)
        if balance is not None:
            args.append(balance)
        args.append(frequency)
        return FunctionCall("ScheduledPrincipal", *args)

    @staticmethod
    def prepaid_principal(
        model: Union[str, float, FormulaExpression],
        wam: Union[str, float, FormulaExpression],
        coupon: Union[str, float, FormulaExpression],
        frequency: Union[Frequency, str],
        balance: Union[str, float, FormulaExpression] = "1",
    ) -> "FunctionCall":
        """
        PrepaidPrincipal - MBS Prepaidprincipal

        PIT Syntax: PrepaidPrincipal( Model , Wam , Coupon , [Balance ], Frequency )

        Args:
            model: The model to compute the ScheduledPrincipal on
            wam: MBS Weighted Average Maturity
            coupon: MBS coupon
            frequency: MBS frequency
            balance: MBS balance (optional)

        Returns:
            FunctionCall representing PrepaidPrincipal(...)
        """
        args = []
        args.append(model)
        args.append(wam)
        args.append(coupon)
        if balance is not None:
            args.append(balance)
        args.append(frequency)
        return FunctionCall("PrepaidPrincipal", *args)

    @staticmethod
    def smm(
        model: Union[str, float, FormulaExpression],
        coupon: Union[str, float, FormulaExpression],
        frequency: Union[Frequency, str],
        balance: Union[str, float, FormulaExpression] = "1",
    ) -> "FunctionCall":
        """
        SMM - MBS SMM

        PIT Syntax: SMM( Model , Coupon , [Balance ], Frequency )

        Args:
            model: The model to compute the SMM on
            coupon: MBS coupon
            frequency: MBS frequency
            balance: MBS balance (optional)

        Returns:
            FunctionCall representing SMM(...)
        """
        args = []
        args.append(model)
        args.append(coupon)
        if balance is not None:
            args.append(balance)
        args.append(frequency)
        return FunctionCall("SMM", *args)

    @staticmethod
    def commo_spread_option(
        model_1: Union[str, float, FormulaExpression],
        model_2: Union[str, float, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        future_date_1: Union[str, date, FormulaExpression],
        future_date_2: Union[str, date, FormulaExpression],
        conversion_factor: Union[str, float, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        usedcorrel: Union[str, float, FormulaExpression] = "-2",
    ) -> "FunctionCall":
        """
        CommoSpreadOption - The keyword computes the price of spark spread option on 2 futures in a multi-asset model

        PIT Syntax: CommoSpreadOption( Model 1 , Model 2 , Expiry Date , Future Date 1 , Future Date 2 , Conversion Factor , Strike , Call/Put , [UsedCorrel ] )

        Args:
            model_1: The 1st model to compute the future with
            model_2: The 2nd model to compute the future with
            expiry_date: Expiry Date of the option
            future_date_1: First Future Date of the spread option
            future_date_2: Second Future Date of the spread option
            conversion_factor: The conversion factor is applied on the 2nd future
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            usedcorrel: Correlation given by user (optional)

        Returns:
            FunctionCall representing CommoSpreadOption(...)
        """
        args = []
        args.append(model_1)
        args.append(model_2)
        args.append(expiry_date)
        args.append(future_date_1)
        args.append(future_date_2)
        args.append(conversion_factor)
        args.append(strike)
        args.append(call_put)
        if usedcorrel is not None:
            args.append(usedcorrel)
        return FunctionCall("CommoSpreadOption", *args)

    @staticmethod
    def implied_correl(
        model_names: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
    ) -> "FunctionCall":
        """
        ImpliedCorrel - compute the implied correlation for many assets

        PIT Syntax: ImpliedCorrel( Model Names , Start Date , Expiry Date )

        Args:
            model_names: The model names
            start_date: Expiry Date of the option
            expiry_date: Expiry Date of the option

        Returns:
            FunctionCall representing ImpliedCorrel(...)
        """
        return FunctionCall("ImpliedCorrel", model_names, start_date, expiry_date)

    @staticmethod
    def basket_option(
        model_names: Union[str, float, FormulaExpression],
        fixing_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        weights: Union[str, float, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        call_put: Union[str, float, FormulaExpression],
        method: Union[str, float, FormulaExpression],
        asset_class: Union[str, float, FormulaExpression] = None,
    ) -> "FunctionCall":
        """
        BasketOption - Prices analytically a basket option. Actually, this keyword works uniquely for Black-Scholes model.

        PIT Syntax: BasketOption( Model Names , Fixing Date , Expiry Date , Weights , Strike , Call/Put , Method , [Asset class ] )

        Args:
            model_names: The model names
            fixing_date: Fixing Date of the option
            expiry_date: Expiry Date of the option
            weights: Vector of Weights
            strike: Call strike in real terms
            call_put: Option's type Call or Put
            method: Method's type Curran or Ju
            asset_class: Equity, Fx or Commodity. Default : Equity (optional)

        Returns:
            FunctionCall representing BasketOption(...)
        """
        args = []
        args.append(model_names)
        args.append(fixing_date)
        args.append(expiry_date)
        args.append(weights)
        args.append(strike)
        args.append(call_put)
        args.append(method)
        if asset_class is not None:
            args.append(asset_class)
        return FunctionCall("BasketOption", *args)

    @staticmethod
    def basket_var_swap(
        model_names: Union[str, float, FormulaExpression],
        start_date: Union[str, date, FormulaExpression],
        expiry_date: Union[str, date, FormulaExpression],
        frequency: Union[Frequency, str],
        weights: Union[str, float, FormulaExpression],
        strike: Union[str, float, FormulaExpression],
        notional: Union[str, float, FormulaExpression],
        volatility_correlation: Union[str, float, FormulaExpression],
        notionaltype: Union[str, float, FormulaExpression] = "STD",
        calendar: Union[Calendar, str] = "NoCalendar",
        annualisation_factor: Union[str, float, FormulaExpression] = "-1",
        interpolation_type: Union[str, float, FormulaExpression] = "STD",
        dividend_adjustment: Union[DateRule, str] = "NONE",
        parametric: Union[str, float, FormulaExpression] = "False",
    ) -> "FunctionCall":
        """
        BasketVarSwap - Basket Variance swap

        PIT Syntax: BasketVarSwap( Model Names , Start Date , Expiry Date , Frequency , Weights , Strike , Notional , Volatility Correlation, [NotionalType ], [Calendar], [Annualisation Factor ], [Interpolation Type ], [Dividend Adjustment], [parametric] )

        Args:
            model_names: The model names
            start_date: Start Date of the option
            expiry_date: Expiry Date of the option
            frequency: Option's type Frequency 1D, 2D, 3D, 4D, 5D, W,...
            weights: Vector of Weights
            strike: Variance swap strike
            notional: Notional
            volatility_correlation: Matrix of correlation between volatilities
            notionaltype: Notional Type STD for standard notional or VEGA for Vega Notional (optional)
            calendar: Calendar (optional)
            annualisation_factor: Number of business days per year, default 252 (optional)
            interpolation_type: Interpolation Type (optional)
            dividend_adjustment: Dividend adjustment method on historical realized variance (optional)
            parametric: Is the swap computed parametrically? If true, you need to use the Heston model (optional)

        Returns:
            FunctionCall representing BasketVarSwap(...)
        """
        args = []
        args.append(model_names)
        args.append(start_date)
        args.append(expiry_date)
        args.append(frequency)
        args.append(weights)
        args.append(strike)
        args.append(notional)
        args.append(volatility_correlation)
        if notionaltype is not None:
            args.append(notionaltype)
        if calendar is not None:
            args.append(calendar)
        if annualisation_factor is not None:
            args.append(annualisation_factor)
        if interpolation_type is not None:
            args.append(interpolation_type)
        if dividend_adjustment is not None:
            args.append(dividend_adjustment)
        if parametric is not None:
            args.append(parametric)
        return FunctionCall("BasketVarSwap", *args)

    @staticmethod
    def cross__currency__swap__fix__fix() -> "FunctionCall":
        """
        Cross Currency Swap Fix-Fix -

        PIT Syntax: CrossCurrencySwapFixFix( StartDate , EndDate , PayRec , DomesticCurrency , DomesticNotional , DomesticFreq , DomesticFixRate , DomesticDayCount , DomesticCalendar , ForeignCurrency , ForeignNotional , ForeignFreq , ForeignFixRate , ForeignDayCount , ForeignCalendar , [ReportConfiguration] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Cross Currency Swap Fix-Fix(...)
        """
        return FunctionCall("Cross Currency Swap Fix-Fix")

    @staticmethod
    def cross__currency__swap__fix__float() -> "FunctionCall":
        """
        Cross Currency Swap Fix-Float -

        PIT Syntax: CrossCurrencySwapFixFloat( StartDate , EndDate , PayRec , DomesticCurrency , DomesticNotional , DomesticFreq , DomesticFixRate , DomesticDayCount , DomesticCalendar , ForeignCurrency , ForeignNotional , ForeignLiborTenor , ForeignSpread , ForeignDayCount , ForeignCalendar , [ReportConfiguration] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Cross Currency Swap Fix-Float(...)
        """
        return FunctionCall("Cross Currency Swap Fix-Float")

    @staticmethod
    def cross__currency__swap__float__fix() -> "FunctionCall":
        """
        Cross Currency Swap Float-Fix -

        PIT Syntax: CrossCurrencySwapFloatFix( StartDate , EndDate , PayRec , DomesticCurrency , DomesticNotional , DomesticLiborTenor , DomesticSpread , DomesticDayCount , DomesticCalendar , ForeignCurrency , ForeignNotional , ForeignFreq , ForeignFixRate , ForeignDayCount , ForeignCalendar , [ReportConfiguration] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Cross Currency Swap Float-Fix(...)
        """
        return FunctionCall("Cross Currency Swap Float-Fix")

    @staticmethod
    def cross__currency__swap__float__float() -> "FunctionCall":
        """
        Cross Currency Swap Float-Float -

        PIT Syntax: CrossCurrencySwapFloatFloat( StartDate , EndDate , PayRec , DomesticCurrency , DomesticNotional , DomesticLiborTenor , DomesticSpread , DomesticDayCount , DomesticCalendar , ForeignCurrency , ForeignNotional , ForeignLiborTenor , ForeignSpread , ForeignDayCount , ForeignCalendar , [ReportConfiguration] )

        Args:
            (no arguments)

        Returns:
            FunctionCall representing Cross Currency Swap Float-Float(...)
        """
        return FunctionCall("Cross Currency Swap Float-Float")


# ============================================================
# Keyword Registry (for introspection)
# ============================================================

GENERATED_KEYWORDS = [
    "If",
    "Max",
    "Min",
    "AsOfDate",
    "AddPeriod",
    "BusinessDate:",
    "FromTo",
    "FromTo",
    "CurrentDate",
    "DCF",
    "DateTable",
    "ResetDate",
    "PayDate",
    "PeriodStart",
    "PeriodEnd",
    "EventDate",
    "AccrualValue",
    "Assign",
    "ColumnVal",
    "DF",
    "Discount factor",
    "E",
    "Exercise",
    "FwdVal",
    "GetValue",
    "ModelFactor",
    "Pay",
    "PV",
    "Receive",
    "Trigger",
    "GetIRMktVol",
    "FormulaValue",
    "CallableBy",
    "Abs",
    "And",
    "ATan",
    "Average",
    "Correl",
    "Cos",
    "CumNorm",
    "Exp",
    "Interpol",
    "Log",
    "Or",
    "Pow",
    "Modulo",
    "Round",
    "Sin",
    "Sqrt",
    "Sum",
    "Product",
    "SumProduct",
    "Tan",
    "NextVal",
    "PreviousVal",
    "Report",
    "Repeat",
    "GetElem",
    "GetElems",
    "Nth",
    "PartialSort",
    "PartialSortWithOptions",
    "Rank: Deprecated",
    "Sort",
    "SortWithOptions",
    "CommoSpot",
    "CommoFwd",
    "CommoCall",
    "CommoDigital",
    "CommoCalendarSpread",
    "CommoHistoVol",
    "CommoBSVol",
    "CommoVarSwap",
    "CommoVolSwap",
    "CommoVarOption",
    "CommoVolOption",
    "CommoBarrier",
    "CommoDoubleBarrier",
    "CommoDigitalBarrier",
    "CommoShiftedBarrier",
    "CommoAsian",
    "DefaultDate",
    "MarginalLoss",
    "AccruedOnDefault",
    "Accrued",
    "BasketAccruedOnDefault",
    "BasketMarginalLoss",
    "BasketNotional",
    "NameInDefault",
    "DefaultNb",
    "NthDefaultDate",
    "TranchedLossSubPool",
    "TranchedLoss",
    "TrancheNotional",
    "RecoveryOnBasket",
    "Recovery",
    "CDSRate",
    "CDSDefaultLeg",
    "CDSPremiumLeg",
    "CDS",
    "NoDefault",
    "TrancheNominal",
    "BasketNominal",
    "CDSProtectionLeg",
    "AccruedOnDefaultIndex",
    "NoDefaultIndex",
    "GetRating",
    "ZSpread",
    "SurvivalProba",
    "EqSpot",
    "EqFwd",
    "EqCall",
    "EqDigital",
    "EqBSVol",
    "EqHistoVol",
    "EqPaidDividends",
    "EqVarSwap",
    "EqVolSwap",
    "EqVarOption",
    "EqVolOption",
    "EqCorridorVarSwap",
    "EqSpotCorridor",
    "EqBarrier",
    "EqDoubleBarrier",
    "EqDigitalBarrier",
    "EquityShiftedBarrier",
    "EqPowerOption",
    "EqAsianOption",
    "EqAmericanCall",
    "Index",
    "FxSpot",
    "FxRate",
    "FxFwd",
    "FxCall",
    "FxDigital",
    "FxHistoVol",
    "FxBSVol",
    "FxVarSwap",
    "FxVolSwap",
    "FxVarOption",
    "FxVolOption",
    "FxBarrier",
    "FxDoubleBarrier",
    "FxDigitalBarrier",
    "FxShiftedBarrier",
    "FxAmericanCall",
    "Annuity",
    "BondKeyword",
    "Cap",
    "CapPower",
    "CapDigital",
    "Caplet",
    "Digital",
    "IrIndex",
    "Libor",
    "PriceToYield",
    "RangeAccrual",
    "ShortRate",
    "SpreadOption",
    "Swap",
    "SwapRate",
    "RFR SwapRate",
    "Swaption",
    "YieldToPrice",
    "CPI",
    "InfSwapRate",
    "InfSwap",
    "LARate",
    "Alive",
    "MortalityRate",
    "Lapse",
    "WithdrawalRate",
    "LapseRate",
    "LifeAnnuityRate",
    "ScheduledPrincipal",
    "PrepaidPrincipal",
    "SMM",
    "CommoSpreadOption",
    "ImpliedCorrel",
    "BasketOption",
    "BasketVarSwap",
    "Cross Currency Swap Fix-Fix",
    "Cross Currency Swap Fix-Float",
    "Cross Currency Swap Float-Fix",
    "Cross Currency Swap Float-Float",
]
