/* Binary operator category definition */

const binaryOperator = {
  name: 'binaryOperator',
  labelFr: 'opérateur binaire',
  items: [
    // Boolean
    {
      name: 'and',
      labelFr: 'Et',
      labelEn: 'And',
      retro: 'Et',
      category: 'binaryOperator',
      inputTypes1: ['boolean'],
      inputTypes2: ['boolean'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      indents: true,
    },
    {
      name: 'or',
      labelFr: 'Ou',
      labelEn: 'Or',
      retro: 'ou',
      category: 'binaryOperator',
      inputTypes1: ['boolean'],
      inputTypes2: ['boolean'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      indents: true,
    },

    // Building
    // {
    //   name: 'sideWallWrtTo',
    //   labelFr: 'Heberges',
    //   labelEn: 'Side wall',
    //   retro: 'hébérges de',
    //   category: 'unaryOperator',
    //   inputTypes: ['neighboringBuilding'],
    //   outputType: 'edge',
    //   inputCanBeList: true,
    //   outputIsList: true,
    //   obligatoryParameters: [],
    //   nonObligatoryParameters: [],
    // },
    {
      name: 'followsSideWallShape',
      labelFr: "S'inscrit dans les héberges de",
      labelEn: 'Follows side wall shape',
      retro: "s'inscrit dans les héberges de @",
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['neighboringBuilding', 'building'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'heightBonusM',
          labelFr: 'bonus de hauteur (mètres)',
          labelEn: 'height bonus (meters)',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
        {
          name: 'heightBonusP',
          labelFr: 'bonus de hauteur (<1)',
          labelEn: 'height bonus (<1)',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
        {
          name: 'heightPenaltyM',
          labelFr: 'malus de hauteur (mètres)',
          labelEn: 'height penalty (meters)',
          type: 'number',
          value: null,
        },
      ],
    },
    {
      name: 'followsSideWallHorizontal',
      labelFr: "S'inscrit dans les héberges horizontales de",
      labelEn: 'Follows horizontal side wall shape',
      retro: "s'inscrit dans les héberges horizontales de @",
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['neighboringBuilding', 'building'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    //uses 'donneeNumUn', 'donneeNumDeux', so has random behavior in case of multiple PGs with different num1 and num2
    //TODO replace this operator in the 2 zones wher eit is used
    {
      name: 'withinSetbackLimitsDefinedByGraphReqs',
      labelFr: 'Est dans la fourchette de retrait définie par prescr. graph.',
      labelEn: 'Is within setback limits given by graph. reqs.',
      deprecated: true,
      retro:
        'est dans la fourchette de retrait définie par prescription graphique',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'rMin',
          labelFr: 'retrait minimal authorisé',
          labelEn: 'minimal authorised setback',
          type: 'function',
          specificArguments: ['donneeNumUn', 'donneeNumDeux'],
          value: null,
        },
        {
          name: 'rMax',
          labelFr: 'retrait maximal authorisé',
          labelEn: 'maximal authorised setback',
          type: 'function',
          specificArguments: ['donneeNumUn', 'donneeNumDeux'],
          value: null,
        },
      ],
    },
    {
      name: 'withinSetbackLimitsDefinedByGraphReqsNew', //not implemented just like the original function
      labelFr: 'Est dans la fourchette de retrait définie par prescr. graph.',
      labelEn: 'Is within setback limits given by graph. reqs.',
      retro:
        'est dans la fourchette de retrait définie par prescription graphique',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'rMin',
          labelFr: 'retrait minimal authorisé',
          labelEn: 'minimal authorised setback',
          type: 'function',
          specificArguments: [
            'donneeNumUnMax',
            'donneeNumDeuxMax',
            'donneeNumUnMin',
            'donneeNumDeuxMin',
          ],
          value: null,
        },
        {
          name: 'rMax',
          labelFr: 'retrait maximal authorisé',
          labelEn: 'maximal authorised setback',
          type: 'function',
          specificArguments: [
            'donneeNumUnMax',
            'donneeNumDeuxMax',
            'donneeNumUnMin',
            'donneeNumDeuxMin',
          ],
          value: null,
        },
      ],
    },
    //uses 'donneeNumUn', 'donneeNumDeux', so has random behavior in case of multiple PGs with different num1 and num2
    {
      name: 'withinHeightLimitsDefinedByGraphReqs',
      labelFr: 'Est dans la fourchette de hauteur définie par prescr. graph.',
      labelEn: 'Is within height limits given by graph. reqs.',
      deprecated: true,
      retro:
        'est dans la fourchette de hauteur définie par prescription graphique',
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'hMin',
          labelFr: 'hauteur minimale authorisée',
          labelEn: 'minimal authorised height',
          type: 'function',
          specificArguments: ['donneeNumUn', 'donneeNumDeux'],
          value: null,
        },
        {
          name: 'hMax',
          labelFr: 'hauteur maximale authorisée',
          labelEn: 'maximal authorised height',
          type: 'function',
          specificArguments: ['donneeNumUn', 'donneeNumDeux'],
          value: null,
        },

        {
          name: 'onlyforHFacade',
          labelFr: 'Pour hFacade uniquement',
          labelEn: 'only for hFaçade',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'heightIndex',
          labelFr: 'Index de hauteur',
          labelEn: 'height index',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'numberOfFloorInstead',
          labelFr: 'le filet prend les niveaux et non des mètres',
          labelEn: 'number of floor instead',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bestHeightOnCorner',
          labelFr:
            'En cas de croisement prendre la voie la plus avantageuse sur Xm',
          labelEn: 'Height bonus around crossroads',
          type: 'function',
          specificArguments: ['minRoadWidth'],
          value: null,
        },
        {
          name: 'sectionLengthForComputationWithSlope',
          labelFr:
            'Longueur de section pour calcul de la hauteur en cas de pente',
          labelEn: 'section length for height computation in case of slope',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'withinHeightLimitsDefinedByGraphReqsNew',
      labelFr: 'Est dans la fourchette de hauteur définie par prescr. graph.',
      labelEn: 'Is within height limits given by graph. reqs.',
      retro:
        'est dans la fourchette de hauteur définie par prescription graphique',
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'hMin',
          labelFr: 'hauteur minimale authorisée',
          labelEn: 'minimal authorised height',
          type: 'function',
          specificArguments: [
            'donneeNumUnMax',
            'donneeNumDeuxMax',
            'donneeNumUnMin',
            'donneeNumDeuxMin',
          ],
          value: null,
        },
        {
          name: 'hMax',
          labelFr: 'hauteur maximale authorisée',
          labelEn: 'maximal authorised height',
          type: 'function',
          specificArguments: [
            'donneeNumUnMax',
            'donneeNumDeuxMax',
            'donneeNumUnMin',
            'donneeNumDeuxMin',
          ],
          value: null,
        },

        {
          name: 'onlyforHFacade',
          labelFr: 'Pour hFacade uniquement',
          labelEn: 'only for hFaçade',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'heightIndex',
          labelFr: 'Index de hauteur',
          labelEn: 'height index',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'numberOfFloorInstead',
          labelFr: 'le filet prend les niveaux et non des mètres',
          labelEn: 'number of floor instead',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bestHeightOnCorner',
          labelFr:
            'En cas de croisement prendre la voie la plus avantageuse sur Xm',
          labelEn: 'Height bonus around crossroads',
          type: 'function',
          specificArguments: ['minRoadWidth'],
          value: null,
        },
        {
          name: 'sectionLengthForComputationWithSlope',
          labelFr:
            'Longueur de section pour calcul de la hauteur en cas de pente',
          labelEn: 'section length for height computation in case of slope',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },

    {
      name: 'isUnderMaximalEnvelopeFromGraphReq',
      labelFr: 'Est en dessous du gabarit issu de prescription graphique',
      labelEn: 'Is under maximal envelope defined by graph. presc.',
      retro: 'est en dessous du gabarit issu de prescription graphique',
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: [
            /* 'frontBorder', 'sideBorder',
             'backBorder', 'roadAxis', 'oppositeBorder', */
            'linearRequirement',
            'surfaceRequirement',
          ],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hFaitage',
            'hEgout',
            'longueurParcelle',
            'donneeNumUn',
            'donneeNumDeux',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'cornerSupplementDistance',
          labelFr: 'distance autour du coin avec bonus de hauteur',
          labelEn: 'distance from corner with height bonus',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'cornerSupplementMeters',
          labelFr: ' bonus de hauteur (mètres) autour du coin',
          labelEn: 'corner height bonus (meters)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'cornerSupplementProportion',
          labelFr: 'bonus de hauteur (proportion < 1) autour du coin',
          labelEn: 'corner height bonus (proportion < 1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'isUnderMaximalEnvelopeBinary',
      labelFr: 'Est en dessous du gabarit issu de bordure',
      labelEn: 'Is under maximal envelope',
      retro: 'est en dessous du gabarit défini par @ et issu de',
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['border'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hFaitage',
            'hEgout',
            'longueurParcelle',
            'dAlignementOppose',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'cornerSupplementDistance',
          labelFr: 'distance autour du coin avec bonus de hauteur',
          labelEn: 'distance from corner with height bonus',
          type: 'function',
          specificArguments: ['dAlignementOppose'],
          value: null,
        },
        {
          name: 'cornerSupplementMeters',
          labelFr: ' bonus de hauteur (mètres) autour du coin',
          labelEn: 'corner height bonus (meters)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'cornerSupplementProportion',
          labelFr: 'bonus de hauteur (proportion < 1) autour du coin',
          labelEn: 'corner height bonus (proportion < 1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bestHeightOnCorner',
          labelFr:
            'En cas de croisement prendre la voie la plus avantageuse sur Xm',
          labelEn: 'Height bonus around crossroads',
          type: 'function',
          specificArguments: ['minRoadWidth'],
          value: null,
        },
      ],
    },
    {
      name: 'maxHeightXYZ',
      labelFr: 'Hauteur max XYZ',
      labelEn: 'Max height XYZ',
      retro:
        'a une hauteure inférieure à la meilleure hauteur Y mètres sur X% de chaque façade et inférieure à Z mètres sur le reste de la façade vis à vis de',
      category: 'binaryOperator',
      inputTypes1: ['building'],
      inputTypes2: ['border'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'bestHeight',
          labelFr: 'meilleure hauteure Y',
          labelEn: 'best height',
          type: 'number',
          value: null,
        },
        {
          name: 'worstHeight',
          labelFr: 'pire hauteure Z',
          labelEn: 'worst height',
          type: 'number',
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'maxProportionOfFacadeBestHeight',
          labelFr: 'proportion maximale de façade avec meilleure hauteure X',
          labelEn: 'max proportion of edge that has best height',
          type: 'number',
          value: null,
        },
        {
          name: 'maxLengthOfFacadeBestHeight',
          labelFr: 'longueur maximale de façade avec meilleure hauteure X',
          labelEn: 'max length of edge that has best height',
          type: 'number',
          value: null,
        },
        {
          name: 'gutterHeightInstead',
          labelFr:
            "comptabiliser la hauteur à l'égout au lieu de la hauteur max",
          labelEn: 'use gutter height instead of max height',
          type: 'boolean',
          value: null,
        },
      ],
    },

    // Footprint
    {
      name: 'edgesByProspect',
      labelFr: 'Façades par la règle des prospects',
      labelEn: 'Edges by prospect',
      retro: 'liste des façades par la règle des prospects vis à vis de',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'linearRequirement'],
      outputType: 'edge',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isAlignedOrSetback',
      labelFr: 'Est alignée ou en retrait orthogonal',
      labelEn: 'Is aligned or setback (minimal setback)',
      retro:
        'est alignée ou en retrait avec une distance mesurée orthogonalement aux façades',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'linearRequirement', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'defaultSetback',
          labelFr: 'Retrait minimal par défaut',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'setbackWithWindows',
          labelFr: 'Retrait minimal pour façades avec fenêtres',
          labelEn: 'Min setback for edges with windows',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithMainWindows',
          labelFr: 'Retrait minimal pour façades avec baies principales',
          labelEn: 'Min setback for edges with main windows',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithNonMainWindows',
          labelFr: 'Retrait minimal pour façades avec baies non-principales',
          labelEn: 'Min setback for edges with non-main windows',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithDirectWindows',
          labelFr:
            'Retrait minimal pour façades avec fenêtres ayant une vue directe',
          labelEn: 'Min setback for edges with windows having direct view',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithNonDirectWindows',
          labelFr:
            'Retrait minimal pour façades avec fenêtres sans vue directe',
          labelEn: 'Min setback for edges with windows not having direct view',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'minAlignedBorders',
          labelFr:
            'Nombre minimal de frontières sur lesquels on doit être partiellement aligné',
          labelEn: 'Min number of border with which we must be aligned',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minHorizontalWindowSize',
          labelFr: 'Taille horizonatale minimale des fenêtres',
          labelEn: 'Min horizontal window size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minVerticalWindowSize',
          labelFr: 'Taille verticale minimale des fenêtres',
          labelEn: 'Min vertical window size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minWindowArea',
          labelFr: 'Superficie minimale des fenêtres',
          labelEn: 'Min window area',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyOnEdgeCenter',
          labelFr: 'Recul mesuré seulement au centre de la façade',
          labelEn: 'Setback measured only from edge center',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de batiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr: 'ou prolonge les facades publiques de batiments contigus',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForFacadePartWithWindowsOrBalconies',
          labelFr: 'distance comptée uniquement depuis fenetres ou balcons',
          labelEn: 'distance from windows and balconies instead',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxAlignedBorders',
          labelFr:
            'Nombre maximal de frontières sur lesquels on peut être partiellement aligné',
          labelEn: 'Max number of border with which we can be aligned',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minWindowHeight',
          labelFr:
            'hauteur de fenetre à partir de laquelle on concidère leur existence',
          labelEn: 'windows height before concideration',
          type: 'function',
          specificArguments: ['hMaxGroundFloor'],
          value: null,
        },
        {
          name: 'setbackMeasuredFomNeighboringBuildings',
          labelFr: 'retrait mesuré depuis batiments voisins',
          labelEn: 'setback measured from neighboring buildings instead',
          type: 'boolean',
          value: null,
        },
      ],
    },
    {
      name: 'isAlignedSetbackWithSpecificAngle',
      labelFr: 'Est aligné ou en retrait avec angle spécifique',
      labelEn: 'is aligned or setback with specific angle',
      retro: 'est en retrait avec angle de @ depuis', //voir les longueurs de facade
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'line', 'linearRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minSetbackAngle',
          labelFr: 'Angle de retrait minimal',
          labelEn: 'min setback angle',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxSetbackAngle',
          labelFr: 'Angle de retrait maximal',
          labelEn: 'max setback angle',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minSetback',
          labelFr: 'Retrait minimal des façades en retrait',
          labelEn: 'min setback',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    // est ce que le batiment entier est couvert par buffers de taille maxWidth depuis facades par prospect
    {
      name: 'buildingWidthWrtIsUnderLimit',
      labelFr: "Limite maximale d'épaisseur du bâtiment vis à vis de",
      labelEn: 'max building width of the building below limit wrt to',
      retro: 'a une épaisseur inférieure à @ vis à vis de',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'maxWidth',
          labelFr: "valeur max de l'épaisseur",
          labelEn: 'Max witdth limit',
          type: 'number',
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'isAligned',
      labelFr: 'Est alignée',
      labelEn: 'Is aligned',
      retro: 'est alignée sur',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: [
        'border',
        'line',
        'linearRequirement',
        'surface',
        'surfaceRequirement',
        'geomObject',
      ],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minAlignedBorders',
          labelFr:
            'Nombre minimal de frontières sur lesquels on doit être aligné',
          labelEn: 'Min number of border with which we must be aligned',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyBlindEdges',
          labelFr: 'seulement pour les façades aveugles',
          labelEn: 'only for blind walls',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de batiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr: 'ou prolonge les facades publiques de batiments contigus',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          value: null,
        },
        {
          name: 'maxDepthOfPunctualSetback',
          labelFr: 'Profondeur maximale des retraits ponctuels ou partiels',
          labelEn: 'Max depth for punctual or partial setbacks',
          type: 'number',
          value: null,
        },
        {
          name: 'buildingsBehindNotAuthorized',
          labelFr: 'bâtiments de second rang non acceptés',
          labelEn: 'buildingsBehindNotAuthorized',
          type: 'boolean',
          value: null,
        },
      ],
    },
    // useful ? is it not redundant and less interesting than maxAlignedUninterruptedLength ?
    {
      name: 'alignedLength',
      labelFr: 'Longueur alignée totale',
      labelEn: 'Totale aligned length',
      retro: 'longueur alignée totale sur', // TODO retro très approximatif
      category: 'binaryOperator',
      inputTypes1: ['footprint', 'constructibilityBand'], //constructibility band added for Boulogne
      inputTypes2: ['border', 'edge', 'line', 'linearRequirement'],
      outputType: 'number',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'maxAlignedUninterruptedLength',
      labelFr: 'Longueur maximale ininterrompue limite sur la bordure',
      labelEn: 'Max aligned uninterrupted length',
      retro: 'a une longueur de façade alignée ininterrompue maximale de @ sur',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'maxLength',
          labelFr: 'Longueur max des façades alignées sur bordure',
          labelEn: 'Max length of the facades on border',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'isPartiallyAligned',
      labelFr:
        'Est alignée sur une portion de la façade ou derrière un autre bâtiment',
      labelEn:
        'Is aligned on a proportion of the facade or behind another building',
      retro:
        'est alignée sur une proportion @ de la façade ou derrière un autre bâtiment par rapport à',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: [
        'border',
        'line',
        'linearRequirement',
        'surfaceRequirement',
        'surface',
      ],
      outputType: 'boolean',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minProportion',
          labelFr: 'proportion minimale',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxProportion',
          labelFr: 'proportion maximale',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de bâtiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr: 'ou prolonge les facades publiques de bâtiments contigus',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minLength',
          labelFr: 'longueur minimale (en mètres)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'buildingsBehindNotAuthorized',
          labelFr: 'bâtiments de second rang non acceptés',
          labelEn: 'buildingsBehindNotAuthorized',
          type: 'boolean',
          value: null,
        },
      ],
    },
    {
      name: 'isSetback',
      labelFr: 'Est en retrait',
      labelEn: 'Minimal orthogonal setback',
      retro: 'est en retrait de @ depuis',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: [
        'border',
        'line',
        'linearRequirement',
        'surface',
        'surfaceRequirement',
      ],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'defaultSetback',
          labelFr: 'Retrait minimal par défaut',
          labelEn: 'Min setback in default case',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'setbackWithWindows',
          labelFr: 'Retrait minimal pour façades avec fenêtres',
          labelEn: 'Min setback for edges with windows',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithMainWindows',
          labelFr: 'Retrait minimal pour façades avec baies principales',
          labelEn: 'Min setback for edges with main windows',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithNonMainWindows',
          labelFr: 'Retrait minimal pour façades avec baies non-principales',
          labelEn: 'Min setback for edges with non-main windows',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithDirectWindows',
          labelFr:
            'Retrait minimal pour façades avec fenêtres ayant une vue directe',
          labelEn: 'Min setback for edges with windows having direct view',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'setbackWithNonDirectWindows',
          labelFr:
            'Retrait minimal pour façades avec fenêtres sans vue directe',
          labelEn: 'Min setback for edges with windows not having direct view',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hMaxFenetreLaPlusHaute',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
        {
          name: 'minSetbackBorders',
          labelFr:
            'Nombre minimal de frontières desquelles on doit être en retrait',
          labelEn: 'Min number of border from which we must setback',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minHorizontalWindowSize',
          labelFr: 'Taille horizonatale minimale des fenêtres',
          labelEn: 'Min horizontal window size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minVerticalWindowSize',
          labelFr: 'Taille verticale minimale des fenêtres',
          labelEn: 'Min vertical window size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minWindowArea',
          labelFr: 'Superficie minimale des fenêtres',
          labelEn: 'Min window area',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyOnEdgeCenter',
          labelFr: 'Recul mesuré seulement au centre de la façade',
          labelEn: 'Setback measured only from edge center',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de bâtiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr:
            'ou prolonge les facades publiques de bâtiments contigus sur bordure adjacente',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForFacadePartWithWindowsOrBalconies',
          labelFr: 'uniquement pour partie de façade avec fenetres ou balcons',
          labelEn: 'ditance from windows and balconies instead',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orFollowHorizontalSideWallShape',
          labelFr: "ou s'inscrit dans les héberges horizontales ",
          labelEn: 'or follow horizontal side wall shape',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'isAlignedOrSetbackLinear',
      labelFr: 'Est alignée ou en retrait dist. lin.',
      labelEn: 'Is aligned or setback linear distance',
      retro: 'est alignée ou en retrait mesuré linéairement de @ depuis',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'linearRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      deprecated: true,
      obligatoryParameters: [
        {
          name: 'defaultSetback',
          labelFr: 'Retrait minimal',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hThisFacade',
            'hEgoutThisFacade',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'minAlignedBorders',
          labelFr:
            'Nombre minimal de frontières sur lesquels on doit être aligné',
          labelEn: 'Min number of border with which we must be aligned',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de bâtiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr: 'ou prolonge les facades publiques de bâtiments contigus',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'isSetbackLinear',
      labelFr: 'Est en retrait distance linéaire',
      labelEn: 'Minimal linear setback',
      deprecated: true,
      retro: 'est en retrait mesuré linéairement de @ depuis',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'line', 'linearRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'setback',
          labelFr: 'Retrait minimal',
          labelEn: 'Min setback',
          type: 'function',
          specificArguments: [
            'donneeNumUn',
            'donneeNumDeux',
            'hEgout',
            'hFaitage',
            'retraitBatimentPremierRangSurParcelleVoisine',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'minSetbackBorders',
          labelFr:
            'Nombre minimal de frontières desquelles on doit être en retrait',
          labelEn: 'Min number of border from which we must setback',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de bâtiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr: 'ou prolonge les facades publiques de bâtiments contigus',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    // i wonder if this is not just the equivalent of a simple 45° gabarit... must give it a thought before implementing
    {
      name: 'isSetbackWithFacadeProjection',
      labelFr: 'Est en retrait minimal avec projection de facade',
      labelEn: 'Minimal setback with facade projection',
      retro: 'est en retrait minimal avec projection de facade au sol @ depuis',
      category: 'binaryOperator',
      inseeCodes: ['00000'], //it is for a PLU that has not been put in data base yet
      inputTypes1: ['footprint'],
      inputTypes2: ['border'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'defaultSetback',
          labelFr: 'Retrait minimal par défaut',
          labelEn: 'Min setback in default case',
          type: 'function',
          specificArguments: ['profileFacade'],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'setbackWithWindows',
          labelFr: 'Retrait minimal pour façades avec fenêtres',
          labelEn: 'Min setback for edges with windows',
          type: 'function',
          specificArguments: ['profileFacade'],
          value: null,
        },
        {
          name: 'setbackWithMainWindows',
          labelFr: 'Retrait minimal pour façades avec baies principales',
          labelEn: 'Min setback for edges with main windows',
          type: 'function',
          specificArguments: ['profileFacade'],
          value: null,
        },
        {
          name: 'setbackWithNonMainWindows',
          labelFr: 'Retrait minimal pour façades avec baies non-principales',
          labelEn: 'Min setback for edges with non-main windows',
          type: 'function',
          specificArguments: ['profileFacade'],
          value: null,
        },
        {
          name: 'setbackWithDirectWindows',
          labelFr:
            'Retrait minimal pour façades avec fenêtres ayant une vue directe',
          labelEn: 'Min setback for edges with windows having direct view',
          type: 'function',
          specificArguments: ['profileFacade'],
          value: null,
        },
        {
          name: 'setbackWithNonDirectWindows',
          labelFr:
            'Retrait minimal pour façades avec fenêtres sans vue directe',
          labelEn: 'Min setback for edges with windows not having direct view',
          type: 'function',
          specificArguments: ['profileFacade'],
          value: null,
        },
        {
          name: 'minHorizontalWindowSize',
          labelFr: 'Taille horizonatale minimale des fenêtres',
          labelEn: 'Min horizontal window size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minVerticalWindowSize',
          labelFr: 'Taille verticale minimale des fenêtres',
          labelEn: 'Min vertical window size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minWindowArea',
          labelFr: 'Superficie minimale des fenêtres',
          labelEn: 'Min window area',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'facadesAreSetback',
      labelFr: 'Façades en retrait ou derrière un autre bâtiment',
      labelEn: 'Facades are setback or behind another building',
      retro:
        'a ses façades par la règle des prospects derrière un autre bâtiment ou en retrait de @ depuis',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'line', 'linearRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minSetback',
          labelFr: 'Retrait minimal',
          labelEn: 'Min setback',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxSetback',
          labelFr: 'Retrait maximal',
          labelEn: 'Max setback',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfExistingBuildings',
          labelFr:
            'ou prolonge les facades publiques de bâtiments préexistants sur la parcelle',
          labelEn: 'orExtendsFacadesOfExistingBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'orExtendsFacadesOfContiguousBuildings',
          labelFr: 'ou prolonge les facades publiques de bâtiments contigus',
          labelEn: 'orExtendsFacadesOfContiguousBuildings',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyBlindEdges',
          labelFr: 'seulement pour les façades aveugles',
          labelEn: 'only for blind walls',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'buildingsBehindNotAuthorized',
          labelFr: 'bâtiments de second rang non acceptés',
          labelEn: 'buildingsBehindNotAuthorized',
          type: 'boolean',
          value: null,
        },
      ],
    },
    {
      name: 'minSetbackFromRoadAxisBinary',
      labelFr: 'Est en retrait des axes des voies de',
      labelEn: 'Minimal setback from road axis by ',
      retro: 'est en retrait des axes des voies de',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['number', 'maximalHeight', 'height'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isBehindAnotherBuilding',
      labelFr: 'Est derrière un autre bâtiment par rapport à',
      labelEn: 'Is behind another building',
      retro: 'est derrière un autre bâtiment par rapport à',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'linearRequirement'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'otherBuildingsInFrontOf',
      labelFr: 'liste de bâtiments devant bordure',
      labelEn: 'other buildings in front of border',
      retro: 'liste de bâtiments devant bordure',
      category: 'binaryOperator',
      inputTypes1: ['footprint'],
      inputTypes2: ['border', 'linearRequirement'],
      outputType: 'building',
      inputCanBeList1: false,
      inputCanBeList2: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Edge
    {
      name: 'minOrthDistanceToEdgeCenter',
      labelFr: "Distance min orthogonale jusqu'au centre de la facade",
      labelEn: 'Min orthogonal distance to edge center',
      deprecated: true,
      category: 'binaryOperator',
      inputTypes1: ['edge'],
      inputTypes2: [
        'edge',
        'geomObject',
        'border',
        'line',
        'footprint',
        'linearRequirement',
        'surfaceRequirement',
        'surface',
      ],
      outputType: 'number',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Number
    {
      name: 'isEqual',
      labelFr: 'Est égal à',
      labelEn: 'Is equal to',
      retro: 'est égal à',
      category: 'binaryOperator',
      inputTypes1: ['number', 'boolean', 'height', 'maximalHeight', 'zoning'],
      inputTypes2: ['number', 'boolean', 'height', 'maximalHeight', 'zoning'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isDifferent',
      labelFr: 'Est différent de',
      labelEn: 'Is different from',
      retro: 'est différent de',
      category: 'binaryOperator',
      inputTypes1: ['number', 'boolean', 'height', 'maximalHeight', 'zoning'],
      inputTypes2: ['number', 'boolean', 'height', 'maximalHeight', 'zoning'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isSuperior',
      labelFr: 'Est supérieur à',
      labelEn: 'is superior to',
      retro: 'est supérieur à',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isInferior',
      labelFr: 'Est inférieur à',
      labelEn: 'Is inferior to',
      retro: 'est inférieur à',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isSuperiorOrEqual',
      labelFr: 'Est supérieur ou égal à',
      labelEn: 'Is greater than',
      retro: 'est supérieur ou égal à',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isInferiorOrEqual',
      labelFr: 'Est inférieur ou égal à',
      labelEn: 'Is inferior or equal to',
      retro: 'est inférieur ou égal à',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'boolean',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'plus',
      labelFr: 'Plus',
      labelEn: 'Plus',
      retro: '+',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minus',
      labelFr: 'Moins',
      labelEn: 'Minus',
      retro: '-',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'multiply',
      labelFr: 'Multiplié par',
      labelEn: 'Multiplied by',
      retro: '*',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'divide',
      labelFr: 'Divisé par',
      labelEn: 'Divided by',
      retro: '/',
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'max',
      labelFr: 'Maximum',
      labelEn: 'Maximum',
      retro: 'maximum binaire', // TODO retro très approximatif
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'min',
      labelFr: 'Minimum',
      labelEn: 'Minimum',
      retro: 'maximum binaire', // TODO retro très approximatif
      category: 'binaryOperator',
      inputTypes1: ['number', 'height', 'maximalHeight'],
      inputTypes2: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Parcel

    {
      name: 'maxCESBinary',
      labelFr: 'CES maximal égal à',
      labelEn: 'maximum LCP is equal to',
      retro: 'a un CES maximal égal à',
      category: 'binaryOperator',
      inputTypes1: ['parcel', 'constructibilityBand'],
      inputTypes2: ['number'],
      outputType: 'boolean',
      inputCanBeList1: true,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    //pour ce CES, les bâtiments ayant la fonction à leurs RDC on prend en compte le 1er étage dans le calcul
    {
      name: 'maxCESBinaryLevel1InsteadOfFootprint',
      labelFr:
        'CES maximal avec empreinte calculée au premier étage si le RdC est',
      labelEn: 'maximum LCR with use specificity is equal to',
      retro:
        'a un CES maximal avec empreinte calculée au premier étage si le RdC est @ égal à',
      category: 'binaryOperator',
      inputTypes1: ['parcel', 'constructibilityBand', 'surface'],
      inputTypes2: ['number'],
      outputType: 'boolean',
      inputCanBeList1: true,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'commerce',
          labelFr: 'commerce',
          labelEn: 'commerce',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'office',
          labelFr: 'bureaux',
          labelEn: 'office',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'workshop',
          labelFr: 'artisanat',
          labelEn: 'workshop',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'warehouse',
          labelFr: 'entrepot',
          labelEn: 'warehouse',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'industry',
          labelFr: 'industrie',
          labelEn: 'industry',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'hotel',
          labelFr: 'hotel',
          labelEn: 'hotel',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'useForBuildingsInsteadOfBuilding',
          labelFr:
            "prend en compte l'ensemble des bâtiments pour le calcul de la proportion",
          labelEn: 'use for buildings instead of building',
          type: 'boolean',
          value: null,
        },
        {
          name: 'minProportionOfThisActivity',
          labelFr: 'proportion minimale de ces activitées',
          labelEn: 'min proportion of this activity',
          type: 'number',
          value: null,
        },
      ],
    },

    // GeomObject
    {
      name: 'contains',
      labelFr: 'Contient',
      labelEn: 'Contains',
      retro: 'contient',
      category: 'binaryOperator',
      inputTypes1: [
        'geomObject',
        'surface',
        'footprint',
        'constructibilityBand',
        'parcel',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'boolean',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'intersects',
      labelFr: 'Intersecte',
      labelEn: 'Intersects',
      retro: 'intersecte',
      category: 'binaryOperator',
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'boolean',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'projection',
      labelFr: 'Projection',
      labelEn: 'Projection',
      retro: 'projeté sur',
      category: 'binaryOperator',
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'edge',
        'border',
        'line',
        'linearRequirement',
      ],
      outputType: 'line',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'buffer',
      labelFr: 'Buffer',
      labelEn: 'Buffer',
      retro: 'bufferisé de',
      category: 'binaryOperator',
      inseeCodes: ['92062'], //just for puteaux
      inputTypes1: ['footprint'],
      inputTypes2: ['number'],
      outputType: 'surface',
      inputCanBeList1: false,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'difference',
      labelFr: 'Difference',
      labelEn: 'Difference',
      retro: 'après différence avec', // TODO retro très approximatif
      category: 'binaryOperator',
      inputTypes1: [
        'surface',
        'footprint',
        'constructibilityBand',
        'parcel',
        'surfaceRequirement',
        /*      'geomObject',
         'edge',
         'border',
         'linearRequirement',
         'line',*/
      ],
      inputTypes2: [
        'surface',
        'footprint',
        'constructibilityBand',
        'parcel',
        'surfaceRequirement',
        'geomObject',
        'edge',
        'border',
        'linearRequirement',
        'line',
      ],
      outputType: 'surface',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'union',
      labelFr: 'Union',
      labelEn: 'Union',
      retro: 'après union avec', // TODO retro très approximatif
      category: 'binaryOperator',
      deprecated: true,
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'geomObject',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'intersection',
      labelFr: 'Intersection',
      labelEn: 'Intersection',
      retro: 'après intersection avec', // TODO retro très approximatif
      category: 'binaryOperator',
      inputTypes1: [
        'surface',
        'footprint',
        'constructibilityBand',
        'parcel',
        'surfaceRequirement',
        /*      'geomObject',
         'edge',
         'border',
         'linearRequirement',
         'line',*/
      ],
      inputTypes2: [
        'surface',
        'footprint',
        'constructibilityBand',
        'parcel',
        'surfaceRequirement',
        /*      'geomObject',
         'edge',
         'border',
         'linearRequirement',
         'line',*/
      ],
      outputType: 'surface',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'maxOrthogonalDistance',
      labelFr: 'Distance orthogonale maximale',
      labelEn: 'Max Orthogonal Distance',
      deprecated: true,
      category: 'binaryOperator',
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'number',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minOrthogonalDistance',
      labelFr: 'Distance orthogonale minimale',
      labelEn: 'Min Orthogonal Distance',
      deprecated: true,
      category: 'binaryOperator',
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'parcel',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'number',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'maxLinearDistance',
      labelFr: 'Distance linéaire maximale',
      labelEn: 'Max Linear Distance',
      retro: 'distance linéaire maximale vers',
      category: 'binaryOperator',
      pro: true,
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'number',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minLinearDistance',
      labelFr: 'Distance linéaire minimale',
      labelEn: 'Min Linear Distance',
      retro: 'distance linéaire minimale vers',
      category: 'binaryOperator',
      inputTypes1: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'linearRequirement',
        'surfaceRequirement',
      ],
      inputTypes2: [
        'geomObject',
        'surface',
        'edge',
        'border',
        'line',
        'footprint',
        'constructibilityBand',
        'linearRequirement',
        'surfaceRequirement',
      ],
      outputType: 'number',
      inputCanBeList1: true,
      inputCanBeList2: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Zoning
    {
      name: 'isEqualOrChild',
      labelFr: 'Est égal à ou enfant de',
      labelEn: 'Is equal to or child of',
      retro: 'est égal à ou enfant de',
      category: 'binaryOperator',
      inputTypes1: ['zoning'],
      inputTypes2: ['zoning'],
      outputType: 'boolean',
      inputCanBeList1: true,
      inputCanBeList2: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
  ],
};

export default binaryOperator;