/* Unary operator category definition */

const unaryOperator = {
  name: 'unaryOperator',
  labelFr: 'opérateur unaire',
  items: [
    // Constructibility band
    {
      name: 'beyondConstructibilityBand',
      labelFr: 'Au-delà de la bande de constructibilité',
      labelEn: 'Beyond the Constructibility Band',
      deprecated: true,
      category: 'unaryOperator',
      inputTypes: ['constructibilityBand'],
      outputType: 'constructibilityBand',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Boolean
    {
      name: 'negation',
      labelFr: 'Négation',
      labelEn: 'Negation',
      retro: 'est FAUX', // TODO retro très approximatif
      category: 'unaryOperator',
      inputTypes: ['boolean'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Border
    {
      name: 'neighboringParcelZoning',
      labelFr:
        'Zonage de la parcelle voisine (pour bordures séparatives seulement)',
      labelEn: 'Zoning of parcel behind border',
      retro: 'le zonage de la parcelle voisine derrière',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'zoning',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'filterByNeighboringParcelZoning',
      labelFr: 'Filtrage par zonage de la parcelle voisine',
      labelEn: 'Fiiltered by zoning of parcel behind border',
      retro: 'tel que le zonage derrière soit @',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'border',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [
        {
          name: 'zoneName',
          labelFr: 'égal ou enfant de:',
          type: 'text',
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'contiguousBuildingsBehind',
      labelFr: 'Bâtiments contigus derrière bordure',
      labelEn: 'Contiguous buildings behind border',
      retro: 'les bâtiments contigus derrière bordure',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'neighboringBuilding',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'behindThereIs',
      labelFr: 'derrière il y a espace publique spécial',
      labelEn: 'behind there is special public space',
      retro: 'il a une de suivants @ derrière',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'bikePath',
          labelFr: 'une voie cyclable',
          type: 'boolean',
          value: null,
        },
        {
          name: 'pedestrianPath',
          labelFr: 'une voie piétonne',
          type: 'boolean',
          value: null,
        },
        {
          name: 'aPark',
          labelFr: 'un parc',
          type: 'boolean',
          value: null,
        },
      ],
    },
    {
      name: 'behindIsBikeOrFootpath',
      labelFr: 'Derrière il y a une voie piètone ou cyclable',
      labelEn: 'Behind there is a bike or footpath',
      retro: 'il y a une voie piètone ou cyclable derrière',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      deprecated: true,
    },
    {
      name: 'behindIsPark',
      labelFr: 'Derrière il y a un parc',
      labelEn: 'Behind there is a park',
      retro: 'il y a un parc derrière',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      deprecated: true,
    },
    {
      name: 'isOnAngle',
      labelFr: 'Constitue un coin',
      labelEn: 'Is part of a corner',
      retro: 'constitue un coin',
      category: 'unaryOperator',
      pro: true,
      inputTypes: ['border'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    {
      name: 'roadWidth',
      labelFr: 'Largeur max de la voie, pour bordure publique',
      labelEn: 'Max width of road for front border',
      retro: 'la largeur de la voie derrière',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minWidthInsteadofMaxWidth',
          labelFr: 'prendre la largeur minimale au lieu de la largeur maximale',
          type: 'boolean',
          value: null,
        },
      ],
    },
    {
      name: 'roadAxisOp',
      labelFr: 'Axe de la voie correspondante (pour bordure publique)',
      labelEn: 'Axis of the corresponding road',
      retro: 'axe de la voie correspondante',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'line',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    {
      name: 'oppositePublicBorderOp',
      labelFr: 'Alignement opposé (pour bordure publique)',
      labelEn: 'Opposite public border',
      retro: 'alignement opposé',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'line',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'borderHasVisualInterstices', // aubervilliers, faire des percées permet de déroger à la règle 8
      labelFr: 'A au moins N percées visuelles',
      labelEn: 'Has at least N visual interstices',
      deprecated: true,
      retro: 'il y a au moins N @ percées visuelles dans la parcelle',
      category: 'unaryOperator',
      inputTypes: ['border'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'n',
          labelFr: 'N ',
          labelEn: 'N',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'intersticeMinWidth',
          labelFr: 'largeur min des percées',
          labelEn: 'min width of interstice',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'intersticeMinDepth',
          labelFr: 'profondeur min des percées',
          labelEn: 'min depth of interstice',
          type: 'function',
          specificArguments: ['parcelMaxDepth'],
          value: null,
        },
        {
          name: 'minLevelConcerned',
          labelFr: 'niveau à partir du quel la percée est obligatoire',
          labelEn: 'min level index',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxLevelConcerned',
          labelFr: "niveau à jusqu'au quel la percée est obligatoire",
          labelEn: 'max level index',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },

    // Building
    {
      name: 'balconySizeLimitation',
      labelFr: 'Limitation taille des saillies',
      labelEn: 'Balcony size limitation',
      retro:
        'ne possède que des balcons et saillies ne dépassant pas les limites suivantes: @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'minHeight',
          labelFr: 'Altitude minimale permise des balcons',
          labelEn: 'Min height authorized for balconies',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxDepth',
          labelFr: 'Profondeur maximale permise des balcons ',
          labelEn: 'Min depth authorized for balconies',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'maxLengthM',
          labelFr: 'Longueur maximale permise des balcons (m) ',
          labelEn: 'Max length authorized for balconies (m)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxLengthP',
          labelFr: 'Longueur maximale permise des balcons (%) ',
          labelEn: 'Max length authorized for balconies (%)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForFacadeWithNonFrontBorderInProspect',
          labelFr:
            'Seulement pour facades ayant des bordures séparatives en prospect',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForFacadeWithoutNonFrontBorderInProspect',
          labelFr:
            'Seulement pour facades n ayant pas de bordures séparatives en prospect',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'balconyOverSidewalkSizeLimitation',
      labelFr: "Limitation taille des saillies sur l'espace publique",
      labelEn: 'Balcony size limits above public space',
      retro:
        "ne possède que des balcons et saillies ne dépassant pas les limites suivantes au dessus de l'espace public: @",
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'minHeight',
          labelFr: 'Altitude minimale permise des balcons',
          labelEn: 'Min height authorized for balconies',
          type: 'function',
          specificArguments: ['hFaitage', 'hEgout'],
          value: null,
        },
        {
          name: 'maxDepth',
          labelFr: 'Profondeur maximale permise des balcons ',
          labelEn: 'Min depth authorized for balconies',
          type: 'function',
          specificArguments: ['hFaitage', 'hEgout'],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'maxLengthM',
          labelFr: 'Longueur maximale permise des balcons (m) ',
          labelEn: 'Max length authorized for balconies (m)',
          type: 'function',
          specificArguments: ['hFaitage', 'hEgout'],
          value: null,
        },
        {
          name: 'maxLengthP',
          labelFr: 'Longueur maximale permise des balcons (%) ',
          labelEn: 'Max length authorized for balconies (%)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'footprint',
      labelFr: 'Empreinte',
      labelEn: 'Footprint',
      retro: "l'empreinte @ de ",
      category: 'unaryOperator',
      inputTypes: ['building', 'level', 'neighboringBuilding'],
      outputType: 'footprint',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minHeightForFootprint',
          labelFr: 'Hauteure minimale pour projection',
          labelEn: 'Min height for projection',
          retro:
            "Hauteure minimale des éléments du bâtiment pour être prise en compte dans le calcul de l'empreinte",
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxHeightForFootprint',
          labelFr: 'Hauteure maximale pour projection',
          labelEn: 'Max height for projection',
          retro:
            "Hauteure maximale des éléments du bâtiment pour être prise en compte dans le calcul de l'empreinte",
          type: 'function',
          specificArguments: ['hEgout'],
          value: null,
        },
        {
          name: 'minBalconyDepthForFootprint',
          labelFr:
            "Profondeur à partir de laquelle les balcons comptent dans l'empreinte",
          labelEn: 'Min depth starting from which balconies count in footprint',
          type: 'number',
          value: null,
        },
      ],
    },
    {
      name: 'maxHeight',
      labelFr: 'Hauteur au faitage ou Hauteur max',
      labelEn: 'Max height',
      retro: 'la hauteur au faitage ou hauteur maximale de',
      category: 'unaryOperator',
      inputTypes: [
        'building',
        'footprint',
        'neighboringBuilding',
        'level',
        'window',
        'edge',
      ],
      outputType: 'maximalHeight',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minHeight',
      labelFr: 'Hauteur minimale',
      labelEn: 'Min height',
      deprecated: true, //has only been used to say that ground floor height is above Xm.
      retro: 'la hauteur minimale de',
      category: 'unaryOperator',
      inputTypes: [
        'building',
        'footprint',
        'neighboringBuilding',
        'level',
        'window',
        'edge',
      ],
      outputType: 'height',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'nbOfFloors',
      labelFr: 'Hauteur en niveaux',
      labelEn: 'Number of floors',
      retro: 'la hauteur en niveaux de',
      category: 'unaryOperator',
      inputTypes: ['building', 'edge', 'neighboringBuilding'],
      outputType: 'maximalHeight',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'heightAtRoofDrain',
      labelFr: "Hauteur à l'égout de toiture",
      labelEn: 'Height at Roof drain',
      retro: "la hauteur à l'égout de toiture de",
      category: 'unaryOperator',
      inputTypes: ['building', 'edge', 'neighboringBuilding'],
      outputType: 'maximalHeight',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'heightComputationWithSlope',
      labelFr: 'Calcul de la hauteur par sections en cas de pente',
      labelEn: 'Height Computation With Slope',
      retro:
        'la hauteur calculée pour les bâtiments en pente en prenant la hauteure maximale sur chaque section de @ mètres',
      category: 'unaryOperator',
      inputTypes: ['building', 'maximalHeight', 'level'],
      outputType: 'maximalHeight',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'maxSectionLength',
          labelFr: "longueur maximale d'une section",
          labelEn: 'max section length',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'isHarmoniouslyInserted',
      labelFr: "S'insère harmonieusement",
      labelEn: 'Is harmoniously inserted',
      retro:
        "s'insère hamonieusement entre les hauteurs des immeubles contigus qui l'ecadrent @",
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'forMaxHeight',
          labelFr: "s'applique pour l'hauteur au faitage",
          type: 'boolean',
          value: null,
        },
        {
          name: 'forGutterHeight',
          labelFr: "s'applique pour l'hauteur à l'égout",
          type: 'boolean',
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'isUnderMaximalEnvelope',
      labelFr: 'Est en dessous du gabarit',
      labelEn: 'Is under maximal envelope',
      retro: 'est en dessous du gabarit défini par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: [
            'element',
            'frontBorder',
            'sideBorder',
            'backBorder',
            'sideAndBackBorder',
            'roadAxis',
            'oppositeBorder',
          ],
          value: null,
        },
        {
          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: 'isAlignedOrUnderMaximalEnvelope',
      labelFr: 'Est aligné ou en dessous du gabarit',
      labelEn: 'Is aligned or under maximal envelope',
      retro: 'est aligné ou en dessous du gabarit défini par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: [
            'element',
            'frontBorder',
            'sideBorder',
            'backBorder',
            'sideAndBackBorder',
            'roadAxis',
            'oppositeBorder',
          ],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hFaitage',
            'longueurParcelle',
            'dAlignementOppose',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'isUnderBuildingEnvelope',
      labelFr: "Est en dessous du gabarit d'immeuble",
      labelEn: 'Is under maximal building envelope',
      retro: "est en dessous du gabarit d'immeuble défini par @",
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: ['edge'],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: ['hFacade', 'hFaitage', 'longueurParcelle'],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'onlyNonAlignedFacades',
          labelFr:
            'Seulement pour facades non-alignées sur limites séparatives',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyFrontPublicFacades',
          labelFr: 'Seulement pour facades publiques',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyMainWindowFacades',
          labelFr: 'Seulement pour facades avec baies principales',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyWindowFacades',
          labelFr: 'Seulement pour facades avec baies',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyNonSideFacades',
          labelFr:
            'Seulement pour facades ne donnant pas sur les limites séparatives',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyNonHebergeFacades',
          labelFr:
            "Seulement pour facades ne s'inscrivant pas dans les hébérges d'un bâtiment voisin",
          type: 'boolean',
          value: null,
        },
        {
          name: 'roundEnvelope',
          labelFr: 'utiliser gabarit circulaire au lieu du gabarit droit',
          type: 'boolean',
          value: null,
        },
      ],
    },
    {
      name: 'lastFloorsSetback',
      labelFr: 'a ses derniers étages en retrait',
      labelEn: 'has last floors set back',
      retro: 'a ses derniers étages en retrait @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minFloorIndex',
          labelFr: "numéro de niveau à partir duquel le retrait s'applique",
          labelEn: 'min floor index for setback',
          type: 'function',
          specificArguments: ['lastLevelIndex'],
          value: null,
        },
        {
          name: 'setback',
          labelFr: 'retrait minimal (par rapport à la façade du bâtiment)',
          labelEn: 'setback',
          type: 'function',
          specificArguments: ['hFaitage', 'hFacade', 'hLevel'],
          value: null,
        },
        {
          name: 'maxFacadeHeight',
          labelFr: 'hauteur max façade sous étages en retrait',
          labelEn: 'max facade height',
          type: 'number',
          value: null,
        },
        {
          name: 'maxHeight',
          labelFr: 'hauteure max avec les étages en retrait',
          labelEn: 'max height with setback floors',
          type: 'function',
          specificArguments: [], // used to have hFacade which never was used and was unclear
          value: null,
        },
        {
          name: 'onlyFrontFacades',
          labelFr: 'Depuis facades publiques',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyMainWindowFacades',
          labelFr: 'Depuis facades avec baies principales',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyWindowFacades',
          labelFr: 'Depuis facades avec baies',
          type: 'boolean',
          value: null,
        },
        {
          name: 'allFacades',
          labelFr: 'Depuis toutes les façades',
          type: 'boolean',
          value: null,
        },
        {
          name: 'forFrontBackFacades',
          labelFr: 'Depuis facades publiques et arrières',
          type: 'boolean',
          value: null,
        },
        {
          name: 'setbackFromPrevLevel',
          labelFr:
            'Retrait par rapport au niveau précedent au lieu de la façade',
          type: 'boolean',
          value: null,
        },
        {
          name: 'forAlignedSideBackFacades',
          labelFr:
            "Depuis facades séparatives sur lesquelles l'empreinte est alignée",
          type: 'boolean',
          value: null,
        },
      ],
    },

    //temporaryForMontreuil UM7 UMAP7 UH7 only for the moment
    {
      name: 'lastFloorsAlignedOrSetback',
      labelFr: 'a ses derniers étages alignés ou en attique',
      labelEn: 'has last floors set back',
      retro: 'a ses derniers étages alignés ou en retrait @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minFloorIndex',
          labelFr: "numéro de niveau à partir duquel le retrait s'applique",
          labelEn: 'min floor index for setback',
          type: 'function',
          specificArguments: ['lastLevelIndex'],
          value: null,
        },
        {
          name: 'setback',
          labelFr: 'retrait par défaut',
          labelEn: 'setback',
          type: 'function',
          specificArguments: ['hFaitage', 'hFacade', 'hLevel'],
          value: null,
        },
        {
          name: 'maxFacadeHeight',
          labelFr:
            "hauteur de façade à partir de laquelle le retrait s'applique",
          labelEn: 'max facade height',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxHeight',
          labelFr: 'hauteure max avec les étages en retrait',
          labelEn: 'max height with setback floors',
          type: 'function',
          specificArguments: ['hFacade'],
          value: null,
        },
        {
          name: 'onlyFrontPublicFacades',
          labelFr: 'Depuis facades publiques',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyMainWindowFacades',
          labelFr: 'Depuis facades avec baies principales',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyWindowFacades',
          labelFr: 'Depuis facades avec baies',
          type: 'boolean',
          value: null,
        },
        {
          name: 'allFacades',
          labelFr: 'Depuis toutes les façades',
          type: 'boolean',
          value: null,
        },
        {
          name: 'setbackFromPrevLevel',
          labelFr:
            'Retrait par rapport au niveau précedent au lieu de la façade',
          type: 'boolean',
          value: null,
        },
        {
          name: 'setbackWithWindows',
          labelFr: "retrait pour facade de l'attqiue avec baies",
          labelEn: 'setback for attic facades with windows',
          type: 'function',
          specificArguments: ['hFaitage', 'hFacade', 'hLevel'],
          value: null,
        },
        {
          name: 'onlySideFacades',
          labelFr: 'Depuis facades latérales',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyNonSideFacades',
          labelFr: 'Depuis facades non-latérales',
          type: 'boolean',
          value: null,
        },
        {
          name: 'onlyAlignedNonFrontFacades',
          labelFr: 'Depuis facades alignées sur séparatives',
          type: 'boolean',
          value: null,
        },
      ],
    },
    // has special specificArguments : ratioPublicAppts for Montreuil
    {
      name: 'isUnderMaximalEnvelopeMoreArguments',
      labelFr: 'Est en dessous du gabarit (version enrichie)',
      labelEn: 'Is under maximal envelope (pro version)',
      inseeCodes: ['93048'],
      retro: 'est en dessous du gabarit défini par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: [
            'element',
            'frontBorder',
            'sideBorder',
            'backBorder',
            'sideAndBackBorder',
            'roadAxis',
            'oppositeBorder',
          ],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hFaitage',
            'hEgout',
            'longueurParcelle',
            'dAlignementOppose',
            'ratioPublicAppts',
          ],
          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,
        },
      ],
    },

    // seen only in Ivry, may be used in other cities
    {
      name: 'isUnderFacadeAndCeilingLimits',
      labelFr: 'Est en dessous hFacade&hPlafond defini par presc graph Ivry',
      labelEn: 'Is under facade and ceiling height given by graph reqs Ivry',
      inseeCodes: ['94041'],
      retro:
        'est en dessous hFacade & hPlafond defini par prescrition graphique (spécial Ivry)',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    // seen only in Argenteuil, applies on for parcelles traversantes
    {
      name: 'isUnderVelumArgenteuil',
      labelFr: 'Est en dessous du velum Argenteuil',
      labelEn: 'Is under velum Argenteuil',
      inseeCodes: ['95018'],
      retro:
        'Est en dessous du velum sur parcelles traversantes (spécial Argenteuil )',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'rule8WithMaximalEnvelope',
      labelFr: 'Règle 8 avec gabarits',
      labelEn: 'Rule 8 with 3D envelope',
      retro:
        'est en dessous des gabarits associés aux autres bâtiments sur la parcelle, définis par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      deprecated: true, // replaced with rule8WithMaximalEnvelopeNew
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: ['otherBuildingEdge'],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hThis',
            'hOther',
            'longueurParcelle',
            'hPremierPlancherAyantBaiePrincipale',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'onlyForEdgesWithMainWindows',
          labelFr:
            'Seules les facades ayant des fenetres principales sont prises en compte',
          labelEn: 'Only edges having main windows are considered',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForHousingOtherBuildings',
          labelFr:
            "Seules les autres bâtiment dédiés à l'habitation sont pris en compte",
          labelEn: 'Only other buildings dedicated to housing are considered',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'rule8WithMaximalEnvelopeNew',
      labelFr: 'Règle 8 avec gabarits',
      labelEn: 'Rule 8 with 3D envelope',
      retro:
        'est en dessous des gabarits associés aux autres bâtiments sur la parcelle, définis par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: ['eachBuildingEdge'],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hCurrent',
            'hOther',
            'longueurParcelle',
            'hPremierPlancherAyantBaiePrincipaleCurrent',
            'hPremierPlancherAyantBaiePrincipaleOther',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'onlyForEdgesWithMainWindows',
          labelFr:
            'Seules les facades ayant des fenetres principales sont prises en compte',
          labelEn: 'Only edges having main windows are considered',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForHousingOtherBuildings',
          labelFr:
            "Seules les autres bâtiment dédiés à l'habitation sont pris en compte",
          labelEn: 'Only other buildings dedicated to housing are considered',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'rule8RoundFromWindowsAndBalconies',
      labelFr:
        'règle 8 avec distances linéaires partant des balcons et fenetres',
      labelEn: 'rule 8 with linear distances  ',
      retro:
        "est en retrait des empreintes des autres bâtiments d'une distance linéaire prise à partir des balcons ou des fenetres égale au moins à @",
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'bufferLengthFromWindows',
          labelFr: 'distance minimale depuis les fenetres',
          labelEn: 'min distance from windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hEgoutThis',
            'hEgoutOther',
            'hEgoutMax',
            'hEgoutMin',
          ],
          value: null,
        },
        {
          name: 'bufferLengthFromMainWindows',
          labelFr: 'distance minimale depuis les baies principales',
          labelEn: 'min distance from main windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
      ],
    },
    {
      name: 'isUnderCircularEnvelope',
      labelFr: 'Est en dessous du gabarit circulaire',
      labelEn: 'Is under circular maximal envelope',
      retro: 'est en dessous du gabarit circulaire défini par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: [
            'element',
            'frontBorder',
            'sideBorder',
            'backBorder',
            'sideAndBackBorder',
            'roadAxis',
            'oppositeBorder',
          ],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: [
            'hFaitage',
            'hEgout',
            'longueurParcelle',
            'dAlignementOppose',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'followsMaximalEnvelope',
      labelFr: 'Epouse le gabarit',
      labelEn: 'Follows maximal envelope',
      retro: 'épouse le gabarit défini par @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'originOfEnvelope',
          labelFr: "ligne servant d'origine au gabarit",
          labelEn: 'origin of envelope',
          type: 'function',
          specificArguments: [
            'element',
            'frontBorder',
            'sideBorder',
            'backBorder',
            'sideAndBackBorder',
            'roadAxis',
            'oppositeBorder',
          ],
          value: null,
        },
        {
          name: 'envelopeCoordiantes',
          labelFr: 'coordonnées du gabarit',
          labelEn: 'envelope coordinates',
          type: 'coordinates',
          specificArguments: ['hFaitage', 'longueurParcelle'],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    //can be written with other concepts
    // {
    //   name: 'maxRatioBetweenTwoHighestFloors',
    //   labelFr: 'Ratio maximal entre surfaces plancher des deux derniers étages',
    //   labelEn: 'Max ratio between floor areas of the two highest floors',
    //   retro: "possède un ratio entre la surface plancher du dernier étage et l'avant dernier étage inférieur à @",
    //   category: 'unaryOperator',
    //   inputTypes: ['building'],
    //   outputType: 'boolean',
    //   inputCanBeList: false,
    //   outputIsList: false,
    //   obligatoryParameters: [
    //     {
    //       name: 'ratioLimit',
    //       labelFr: 'ratio maximal',
    //       labelEn: 'max ratio',
    //       type: 'number',
    //       specificArguments: [],
    //       value: null,
    //     },
    //   ],
    //   nonObligatoryParameters: [],
    // },
    {
      name: 'hasSpecificRoof',
      labelFr: 'Possède une toiture spécifique',
      labelEn: 'Has specific roof',
      retro: 'possède une toiture spécifique',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'terrasseRoof',
          labelFr: 'Toiture terrasse',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'slopedRoof',
          labelFr: 'Toiture en pente',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'greenRoof',
          labelFr: 'végétalisée',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'slopedRoofWithMansards',
          labelFr: 'avec mansardes',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxAngle',
          labelFr: 'pente maximale (en degrés)',
          labelEn: 'max slope (in degrees)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'singleslopedRoof',
          labelFr: 'toit à pente unique',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'doubleslopedRoof',
          labelFr: 'toit à double pente',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minAngle',
          labelFr: 'pente minimale (en degrés)',
          labelEn: 'min slope (in degrees)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'hasGreenRoof',
      labelFr: 'Possède toiture végétalisée',
      labelEn: 'Has green roof',
      retro: 'possède une toiture végétalisée',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      deprecated: true,
    },
    {
      name: 'hasTerrasseRoof',
      labelFr: 'Possède toiture terrasse',
      labelEn: 'Has terrasse roof',
      retro: 'possède une toiture terrasse',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      deprecated: true,
    },
    {
      name: 'hasMansardRoof',
      labelFr: 'Possède toiture Mansart',
      labelEn: 'Has Mansard roof',
      retro: 'possède une toiture Mansart',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
      deprecated: true,
    },
    {
      name: 'hasAtticLevels',
      labelFr: 'Possède étages en retrait',
      labelEn: 'Has attic levels',
      retro: 'possède une toiture Mansart',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'hasWindows',
      labelFr: 'Possède des fenêtres',
      labelEn: 'Has windows',
      retro: 'possède des fenêtres @',
      category: 'unaryOperator',
      inputTypes: ['building', 'level', 'neighboringBuilding', 'edge'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minHorizontalSize',
          labelFr: 'Dimension horizontale minimale',
          labelEn: 'Min horizontal size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minVerticalSize',
          labelFr: 'Dimension verticale minimale',
          labelEn: 'Min vertical size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'windows',
      labelFr: 'Liste des fenêtres',
      labelEn: 'Windows',
      pro: true,
      retro: 'liste des fenêtres @ de',
      category: 'unaryOperator',
      inputTypes: ['building', 'level', 'neighboringBuilding', 'edge'],
      outputType: 'window',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minHorizontalSize',
          labelFr: 'Dimension horizontale minimale',
          labelEn: 'Min horizontal size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minVerticalSize',
          labelFr: 'Dimension verticale minimale',
          labelEn: 'Min vertical size',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'hasMainWindows',
      labelFr: 'Possède des baies principales',
      labelEn: 'Has main windows',
      retro: 'possède des baies principales',
      category: 'unaryOperator',
      inputTypes: ['building', 'level', 'neighboringBuilding', 'edge'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'hasWindowsWithView',
      labelFr: 'Possède des fenetres avec vue directe',
      labelEn: 'Has windows with direct view',
      retro: 'possède des fenetres avec vue directe sur les parcelles voisines',
      category: 'unaryOperator',
      inputTypes: ['building', 'level', 'neighboringBuilding', 'edge'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'groundLevel',
      labelFr: 'RDC',
      labelEn: 'Ground level',
      retro: 'le rez de chaussée de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'level',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'highestLevel',
      labelFr: 'Dernier niveau',
      labelEn: 'Highest level',
      retro: 'le dernier niveau de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'level',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'mezzanineLevels',
      labelFr: 'Niveaux avec mezzanines',
      labelEn: 'Levels that have a mezzanine',
      pro: true,
      deprecated: true,
      retro: 'liste des niveaux possèdant des mezzanines de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'level',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'underGroundLevels',
      labelFr: 'Sous-sols/Fondations',
      labelEn: 'Underground levels',
      retro: 'liste des niveaux Sous-sols/Fondations',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'level',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'floorNumberN', // reduntant with next operator, but allows to avoid using list operators
      labelFr: 'Niveau N du bâtiment',
      labelEn: 'Floor number N of the building',
      retro: 'niveau numéro @ de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'level',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'floorNumber',
          labelFr: 'N',
          type: 'function',
          specificArguments: ['numDernierNiveau'],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'levels',
      labelFr: 'Niveaux',
      labelEn: 'Levels',
      retro: 'liste des niveaux @ de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'level',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'maxLevelIndex',
          labelFr: 'Numéro de niveau maximal',
          type: 'function',
          specificArguments: ['numDernierNiveau'],
          value: null,
        },
        {
          name: 'minLevelIndex',
          labelFr: 'Numéro de niveau minimal',
          type: 'function',
          specificArguments: ['numDernierNiveau'],
          value: null,
        },
      ],
    },
    {
      name: 'chamferedCorner',
      labelFr: 'Pan coupé',
      labelEn: 'Chamfered corner',
      retro: 'respecte un pan coupé defini par @ en cas de parcelle en coin',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minSetback',
          labelFr: 'Retrait minimal ',
          type: 'function',
          specificArguments: ['lRouteLaMoinsLarge', 'lRouteLaPlusLarge'],
          value: null,
        },
        {
          name: 'minLength',
          labelFr: 'Longueure minimale',
          type: 'function',
          specificArguments: ['lRouteLaMoinsLarge', 'lRouteLaPlusLarge'],
          value: null,
        },
        {
          name: 'maxLength',
          labelFr: 'Longueure maximale',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyAcuteAngles',
          labelFr: 'Seulement pour angles aigus',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minLengthOnSide',
          labelFr: 'Longueure minimale du coté du pac coupé',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minHeightOfApplication',
          labelFr: 'Hauteur minimale sur lequel il faut respecter le pan coupé',
          type: 'function',
          specificArguments: ['hGroundFloor'],
          value: null,
        },
      ],
    },
    {
      name: 'inversechamferedCorner',
      labelFr: 'Angle de 90° dans pan coupé',
      labelEn: 'Inversed chamfered corner',
      deprecated: true,
      retro:
        'respecte un angle de 90° dans un pan coupé defini par @ en cas de parcelle en coin',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'minSetback',
          labelFr: 'Retrait minimal ',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'minLength',
          labelFr: 'Longueure minimale',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxLength',
          labelFr: 'Longueure maximale',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'proportionOf',
      labelFr: 'Proportion de : logement, LLS, commerce, bureaux',
      labelEn: 'Proportion of: housing, public housing, commerce, offices',
      deprecated: true,
      retro:
        'somme des proportions de surface brute dédiées aux usages suivants: @ dans',
      category: 'unaryOperator',
      inputTypes: ['building', 'level'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'housing',
          labelFr: 'logement',
          labelEn: 'housing',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'commerce',
          labelFr: 'commerce',
          labelEn: 'commerce',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'office',
          labelFr: 'bureaux',
          labelEn: 'office',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'publicHousing',
          labelFr: 'logement social',
          labelEn: 'public housing',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'proportionOfNew',
      labelFr: 'Proportion de : logement, commerce, bureaux...',
      labelEn: 'Proportion of: housing, commerce, offices...',
      retro:
        'somme des proportions de surface brute dédiées aux usages suivants: @ dans',
      category: 'unaryOperator',
      inputTypes: ['building', 'level'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'housing',
          labelFr: 'logement',
          labelEn: 'housing',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          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: 'public',
          labelFr: 'publique',
          labelEn: 'public',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'publicHousing',
          labelFr: 'logement social',
          labelEn: 'public housing',
          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,
        },
      ],
    },
    // never used apparently
    {
      name: 'proportionOfHousingBetweenTwoFloorArea',
      labelFr: 'Proportion de logement comprise entre deux surfaces plancher',
      labelEn: 'proportion of housing between two floor area',
      deprecated: true,
      retro:
        'possède une proportion maximale de logements compris entre les surfaces planchers',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'maxRatio',
          labelFr: 'ratio maximal',
          labelEn: 'maximal ratio',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'lowerFloor',
          labelFr: "Minimum de surface placher d'un logement",
          labelEn: 'lower floor',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'higherFloor',
          labelFr: "Maximum de surface placher d'un logement",
          labelEn: 'higherFloor',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'nbAppartments',
      labelFr: 'Nombre de logements',
      labelEn: 'Number of appartments',
      retro: "nombre d'appartements @ dans",
      category: 'unaryOperator',
      inputTypes: ['building', 'level'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'publicHousingOnly',
          labelFr: 'logement social seulement',
          labelEn: 'public housing only',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'floorArea',
      labelFr: 'Surface brute',
      labelEn: 'Floor area',
      retro: 'surface brute de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'floorAreaSP',
      labelFr: 'Surface plancher',
      labelEn: 'Floor area (Surface Plancher)',
      retro: 'surface plancher de',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'nbOfFlats',
      labelFr: 'Nombre de logements',
      labelEn: 'Number of flats',
      deprecated: true,
      retro: 'nombre de logements dans @',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'publicHousingOnly',
          labelFr: 'logement social seulement',
          labelEn: 'public housing only',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },

    // { // never used yet
    //     name: 'extendsFacadesOf',
    //     labelFr: 'Prolonge les facades publiques de bâtiments existants ou contigus',
    //     labelEn: 'extends public facades of existing or contiguous buildings',
    //     retro: 'prolonge les facades publiques de bâtiments existants ou contigus @',
    //     category: 'binaryOperator',
    //     inputTypes: ['building'],
    //     outputType: 'boolean',
    //     inputCanBeList: false,
    //     outputIsList: false,
    //     obligatoryParameters: [],
    //     nonObligatoryParameters: [
    //         {
    //             name: 'forExistingOnly',
    //             labelFr: "s'apllique seulement aux bâtiments existants",
    //             labelEn: 'for existing only',
    //             type: 'boolean',
    //             specificArguments: [],
    //             value: null,
    //         },
    //         {
    //             name: 'forContiguousOnly',
    //             labelFr: "s'applique seulement aux bâtiments contigus",
    //             labelEn: 'for contiguous only',
    //             type: 'boolean',
    //             specificArguments: [],
    //             value: null,
    //         },
    //         {
    //             name: 'isAlignedWhenNoBuilding',
    //             labelFr: 'est aligné sur bordure publique en absence de bâtiment contigu',
    //             labelEn: 'is aligned in absence of building',
    //             type: 'boolean',
    //             specificArguments: [],
    //             value: null,
    //         },
    //         {
    //             name: 'maintainsSetbackWhenNoBuilding',
    //             labelFr: 'maintient le retrait en absence de bâtiment contigu',
    //             labelEn: 'maintains setback in absence of building',
    //             type: 'boolean',
    //             specificArguments: [],
    //             value: null,
    //         },
    //     ],
    // },

    // Building on neighboring parcel
    {
      name: 'sideWall',
      labelFr: 'Heberges',
      labelEn: 'Side wall',
      retro: 'hébérges de',
      category: 'unaryOperator',
      inputTypes: ['neighboringBuilding'],
      outputType: 'edge',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    //To be deleted, used temporarily in St Omer
    {
      name: 'blindSideWall',
      labelFr: 'Pignon',
      labelEn: 'Blind side wall',
      deprecated: true,
      retro: 'pignons de',
      category: 'unaryOperator',
      inputTypes: ['neighboringBuilding'],
      outputType: 'edge',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Footprint
    {
      name: 'edges',
      labelFr: 'Façades',
      labelEn: 'Edges',
      retro: 'les façades de',
      deprecated: true,
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'edge',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minSetbackFromRoadAxis',
      labelFr: 'Est en retrait des axes des voies',
      labelEn: 'Minimal setback from road axis',
      retro: 'est en retrait des axes des voies',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'minSetback',
          labelFr: 'Retrait minimal',
          labelEn: 'Min setback',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'minNumberOfRoadAxis',
          labelFr:
            'Nombre minimal de voies sur lesquelles ce retrait est appliqué',
          labelEn: 'min number of road axis',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxNumberOfRoadAxis',
          labelFr:
            'Nombre maximal de voies sur lesquelles ce retrait est appliqué',
          labelEn: 'max number of road axis',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'rule8Round',
      labelFr: 'règle 8 avec distances linéaires',
      labelEn: 'rule 8 with linear distances  ',
      retro:
        "est en retrait des empreintes des autres bâtiments d'une distance linéaire égale au moins à @",
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'bufferLength',
          labelFr: 'distance minimale inter-bâtiments',
          labelEn: 'min distance between buildings',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hEgoutThis',
            'hEgoutOther',
            'hEgoutMax',
            'hEgoutMin',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'onlyIfBothBuildingsAreHousing',
          labelFr: "Seulement si les deux bâtiments sont à usage d'habitation",
          labelEn: 'onlyIfBothBuildingsAreHousing',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyIfBothBuildingsAreActivity',
          labelFr:
            "Seulement si les deux bâtiments sont à usage d'activité économique",
          labelEn: 'onlyIfBothBuildingsAreActivity',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'rule8Orth',
      labelFr: 'règle 8 avec distances orthogonales',
      labelEn: 'rule 8 with orthogonal distances',
      retro:
        "est en retrait des empreintes des autres bâtiments d'une distance orthogonale égale au moins à @",
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'defaultBufferLength',
          labelFr: 'distance minimale inter-bâtiments par défaut',
          labelEn: 'min distance between buildings by default',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
            'hRDC',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'bufferLengthWithWindows',
          labelFr: 'distance minimale si la façade du bâtiment a des fenêtres',
          labelEn: 'min distance if facade has windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
            'hRDC',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithMainWindows',
          labelFr:
            'distance minimale si la façade du bâtiment a des baies principales',
          labelEn: 'min distance if facade has main windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
            'hRDC',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithNonMainWindows',
          labelFr:
            'distance minimale si la façade du bâtiment a des baies non principales',
          labelEn: 'min distance if façade has non-main windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
            'hRDC',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithDirectWindows',
          labelFr:
            'distance minimale si la façade du bâtiment a des fenêtres avec vue directe',
          labelEn: 'min distance if facade has windows with direct view',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
            'hRDC',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithNonDirectWindows',
          labelFr:
            'distance minimale si la façade du bâtiment a des fenêtres sans vue directe',
          labelEn: 'min distance if facade has windows without direct view',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
            'hRDC',
          ],
          value: null,
        },

        {
          name: 'minHorizontalWindowSize',
          labelFr: 'Taille horizontale 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: 'onlyOnEdgeCenter',
          labelFr: 'Recul mesuré seulement au centre de la façade',
          labelEn: 'Setback measured only from edge center',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'rule8OrthAlternative',
      labelFr: 'règle 8 altérnative avec distances orthogonales',
      labelEn: 'rule 8 (alternative) with orthogonal distances',
      retro:
        "est en retrait des empreintes des autres bâtiments d'une distance orthogonale égale au moins à @",
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'defaultBufferLength',
          labelFr: 'distance minimale inter-bâtiments par défaut',
          labelEn: 'min distance between buildings by default',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'bufferLengthWithWindowsOnOnlyOneFacade',
          labelFr:
            'distance minimale si une seulement des facades ont des fenêtres',
          labelEn: 'min distance if only one facade has windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithWindowsOnLowestFacade',
          labelFr:
            'distance minimale si uniquement la façade basse a des fenêtres',
          labelEn: 'min distance if only the lowest facade has windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithWindowsOnHighestFacade',
          labelFr:
            'distance minimale si uniquement la façade haute a des fenêtres',
          labelEn: 'min distance if only the highest facade has windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithWindowsOnBothFacades',
          labelFr: 'distance minimale les deux facades ont des fenêtres', //TODO make it obligatory
          labelEn: 'min distance if both facades windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'minHorizontalWindowSize',
          labelFr: 'Taille horizontale 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: 'onlyOnEdgeCenter',
          labelFr: 'Recul mesuré seulement au centre de la façade',
          labelEn: 'Setback measured only from edge center',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyForDirectViews',
          labelFr:
            'Seules les fenetres avec vue sont considerees comme fenetres',
          labelEn: 'Only windows with views are considered windows',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bufferLengthWithMainWindowsOnHighestFacade',
          labelFr:
            'distance minimale si la façade du bâtiment le plus haut a des baies principales',
          labelEn: 'min distance if highest facade highest has main windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithMainWindowsOnLowestFacade',
          labelFr:
            'distance minimale si la façade du bâtiment le plus bas a des baies principales',
          labelEn: 'min distance if lowest facade has main windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'bufferLengthWithMainWindowsOnBothFacade',
          labelFr:
            'distance minimale si les facades des deux bâtiments ont des baies principales',
          labelEn: 'min distance if both facades have main windows',
          type: 'function',
          specificArguments: [
            'hThis',
            'hOther',
            'hMax',
            'hMin',
            'hFacadeThis',
            'hFacadeOther',
            'hFacadeMax',
            'hFacadeMin',
          ],
          value: null,
        },
        {
          name: 'minWindowHeight',
          labelFr:
            'hauteur de fenetre à partir de laquelle on considère leur existence',
          labelEn: 'windows height before concideration',
          type: 'function',
          specificArguments: ['hMaxGroundFloor'],
          value: null,
        },
      ],
    },
    {
      name: 'thisBuildingFacadesOrthSetback',
      labelFr: 'a les facades en vis à vis en retrait orthogonal',
      labelEn: 'has facades facing each other sufficiently setback',
      retro:
        "a les facades en retrait orthogonal l'une de l'autre d'au moins @",
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'bufferLength',
          labelFr: 'distance orthogonale minimale',
          labelEn: 'min orthogonal distance',
          type: 'function',
          specificArguments: ['hThis'],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'onlyWhenOneFacadeHasWindows',
          labelFr: "ne s'applique qu'en présence d'une fenêtre",
          labelEn: 'applies only when one window is présent',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyWhenBothFacadeHasWindows',
          labelFr: "ne s'applique que si les deux facades ont fenêtres",
          labelEn: 'applies only when btoh facades have windows',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyNonAdjancentFacades',
          labelFr: "ne s'applique pas au facades adjacentes",
          labelEn: 'does not apply to adjacent facades',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyMultipolygonFloors', //in this case hThis should only be the height counted from the highest non-multipolygonfloor
          labelFr: "ne s'applique pas que pour niveaux multipolygons",
          labelEn: 'does not apply to multipolygon floors',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    // only used in Ivry
    {
      name: 'rule8CustomIvry',
      labelFr: 'règle 8 spéciale Ivry',
      labelEn: 'rule 8 custom for Ivry',
      inseeCodes: ['94041'],
      retro: 'respecte la règle 8 spéciale Ivry',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'rule7CustomIvry',
      labelFr: 'règle 7 spéciale Ivry',
      labelEn: 'rule 7 custom for Ivry',
      inseeCodes: ['94041'],
      retro: 'respecte la règle 7 spéciale Ivry',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    // only used in Joinville
    {
      name: 'rule6CustomJoinvilleUA',
      labelFr: 'règle 6 spéciale JoinvilleUA',
      labelEn: 'rule 6 custom for JoinvilleUA',
      inseeCodes: ['94042'],
      retro: 'respecte la règle 6 spéciale JoinvilleUA',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'rule6CustomJoinvilleUD',
      labelFr: 'règle 6 spéciale JoinvilleUD',
      labelEn: 'rule 6 custom for JoinvilleUD',
      inseeCodes: ['94042'],
      retro: 'respecte la règle 6 spéciale JoinvilleUD',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'rule6CustomJoinvilleUE',
      labelFr: 'règle 6 spéciale JoinvilleUE',
      labelEn: 'rule 6 custom for JoinvilleUE',
      inseeCodes: ['94042'],
      retro: 'respecte la règle 6 spéciale JoinvilleUE',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'rule6CustomJoinvilleUG',
      labelFr: 'règle 6 spéciale JoinvilleUG',
      labelEn: 'rule 6 custom for JoinvilleUG',
      inseeCodes: ['94042'],
      retro: 'respecte la règle 6 spéciale JoinvilleUG',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    //only used in epinay sur seine
    {
      name: 'maxHeightForPartOfParcel',
      labelFr: 'hauteur maximale sur une partie de la parcelle',
      labelEn: 'max  height for part of parcel',
      retro: 'la hauteur maximale sur une partie de la parcelle est respectée',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      deprecated: true,
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'partOfTheParcel',
          labelFr: 'proportion de la parcelle',
          labelEn: 'min proportion of parcel area',
          type: 'number',
          value: null,
        },
        {
          name: 'heightOfThisParcelPart',
          labelFr: 'hauteur de cette partie de la parcelle',
          labelEn: 'height of this parcel part',
          type: 'number',
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'heightOfTheOtherParcelPart',
          labelFr: 'hauteur de l autre partie de la parcelle',
          labelEn: 'height of the other parcel part',
          type: 'number',
          value: null,
        },
        {
          name: 'heightType',
          labelFr: 'Index de hauteur utilisé',
          labelEn: 'height type',
          type: 'number',
          value: null,
        },
      ],
    },
    // only used in Aubervilliers
    {
      name: 'rule6CustomAubervilliers',
      labelFr: 'règle 6 spéciale Aubervilliers',
      labelEn: 'rule 6 custom for Aubervilliers',
      inseeCodes: ['93001'],
      retro: 'respectent la règle 6 spéciale Aubervilliers',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'minProportion',
          labelFr: "proportion minimale d'alignement",
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },

    // only used in Romainville
    {
      name: 'rule6CustomRomainville',
      labelFr: 'règle 6 spéciale Romainville',
      labelEn: 'rule 6 custom for Romainville',
      retro: 'respecte la règle 6 spéciale Romainville',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    {
      name: 'rule6bisCustomRomainville',
      labelFr: 'règle 6 bis spéciale Romainville',
      labelEn: 'rule 6 bis custom for Romainville',
      inseeCodes: ['93063'],
      retro: 'respecte la règle 6 bis spéciale Romainville',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    // only used in Boulogne Billancourt
    {
      name: 'ruleCustomFiletsBandeEBoulogne',
      labelFr: 'règle 10 spéciale Boulogne Billancourt',
      labelEn: 'rule 10 custom for Boulogne Billancourt',
      inseeCodes: ['92012'],
      retro: 'respecte la règle 10 spéciale Boulogne Billancourt',
      category: 'unaryOperator',
      inputTypes: ['building'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'envelopeCoordiantesR2',
          labelFr: 'coordonnées du gabarit R+2+1',
          labelEn: 'envelope coordinates R2',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR3',
          labelFr: 'coordonnées du gabarit R+3+1',
          labelEn: 'envelope coordinates R3',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR4',
          labelFr: 'coordonnées du gabarit R+4+1',
          labelEn: 'envelope coordinates R4',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR5',
          labelFr: 'coordonnées du gabarit R+5+1',
          labelEn: 'envelope coordinates R5',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR6',
          labelFr: 'coordonnées du gabarit R+5+2',
          labelEn: 'envelope coordinates R6',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR7',
          labelFr: 'coordonnées du gabarit R+6+2',
          labelEn: 'envelope coordinates R7',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR8',
          labelFr: 'coordonnées du gabarit R+8+2',
          labelEn: 'envelope coordinates R8',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR9',
          labelFr: 'coordonnées du gabarit R+10+2',
          labelEn: 'envelope coordinates R9',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'bonusDistanceR2',
          labelFr: 'Distance bonus en cas de coin R+2+1',
          labelEn: 'Bonus distanceR2',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR3',
          labelFr: 'Distance bonus en cas de coin R+3+1',
          labelEn: 'Bonus distanceR3',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR4',
          labelFr: 'Distance bonus en cas de coin R+4+1',
          labelEn: 'Bonus distanceR4',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR5',
          labelFr: 'Distance bonus en cas de coin R+5+1',
          labelEn: 'Bonus distanceR5',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR6',
          labelFr: 'Distance bonus en cas de coin R+5+2',
          labelEn: 'Bonus distanceR6',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR7',
          labelFr: 'Distance bonus en cas de coin R+6+2',
          labelEn: 'Bonus distanceR7',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR8',
          labelFr: 'Distance bonus en cas de coin R+8+2',
          labelEn: 'Bonus distanceR8',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'bonusDistanceR9',
          labelFr: 'Distance bonus en cas de coin R+10+2',
          labelEn: 'Bonus distanceR8',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'ucud',
          labelFr: 'UC ? UD ?',
          labelEn: 'UC ? UD ?',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'ruleCustomFiletsHorsBandeEBoulogne',
      labelFr: 'règle 10 spéciale Boulogne Billancourt hors bande E',
      labelEn: 'rule 10 custom for Boulogne Billancourt',
      inseeCodes: ['92012'],
      retro: 'respecte la règle 10 spéciale Boulogne Billancourt hors bande E',
      category: 'unaryOperator',
      inputTypes: ['constructibilityBand'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'uaa',
          labelFr: 'UAa ?',
          labelEn: '',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'envelopeCoordiantesR2',
          labelFr: 'coordonnées du gabarit R+2+1',
          labelEn: 'envelope coordinates R2',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR3',
          labelFr: 'coordonnées du gabarit R+3+1',
          labelEn: 'envelope coordinates R3',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR4',
          labelFr: 'coordonnées du gabarit R+4+1',
          labelEn: 'envelope coordinates R4',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR5',
          labelFr: 'coordonnées du gabarit R+5+1',
          labelEn: 'envelope coordinates R5',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR6',
          labelFr: 'coordonnées du gabarit R+5+2',
          labelEn: 'envelope coordinates R6',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR7',
          labelFr: 'coordonnées du gabarit R+6+2',
          labelEn: 'envelope coordinates R7',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR8',
          labelFr: 'coordonnées du gabarit R+8+2',
          labelEn: 'envelope coordinates R8',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
        {
          name: 'envelopeCoordiantesR9',
          labelFr: 'coordonnées du gabarit R+10+2',
          labelEn: 'envelope coordinates R9',
          type: 'coordinates',
          specificArguments: ['longueurParcelle'],
          value: null,
        },
      ],
    },

    // used only in Boulogne for the moment
    // UAb 10.2.1 //https://buildrz.slack.com/files/maud/F6NFKMT6K/image.png
    {
      name: 'maxHeightOnSurfaceProportion',
      labelFr: 'Hauteurs maximales sur proportions de la surface',
      labelEn: 'Max heights on surface proportions',
      retro: 'respecte les hauteurs maximales sur les differente proportions',
      category: 'unaryOperator',
      inputTypes: ['surface', 'constructibilityBand', 'parcel'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'maxHeight1',
          labelFr: 'Hmax 1(> Hmax2)',
          labelEn: 'Hmax 1',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'proportion1',
          labelFr: 'Proportion 1 (<1)',
          labelEn: 'Proportion 1 (<1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxHeight2',
          labelFr: 'Hmax 2(> Hmax3)',
          labelEn: 'Hmax 2',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'proportion2',
          labelFr: 'Proportion 2 (<1)',
          labelEn: 'Proportion 2 (<1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'maxHeight3',
          labelFr: 'Hmax 3 (> Hmax4)',
          labelEn: 'Hmax 3',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'proportion3',
          labelFr: 'Proportion 3 (<1)',
          labelEn: 'Proportion 3 (<1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'maxHeight4',
          labelFr: 'Hmax 4',
          labelEn: 'Hmax 4',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'proportion4',
          labelFr: 'Proportion 4 (<1)',
          labelEn: 'Proportion 4 (<1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },

    // only used in Nanterre UE

    {
      name: 'rule8CustomNanterre',
      labelFr: 'règle 8 spéciale Nanterre',
      labelEn: 'rule 8 custom for Nanterre',
      inseeCodes: ['92012'],
      retro: 'respecte la règle 8 spéciale Nanterre',
      category: 'unaryOperator',
      inputTypes: ['footprint'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'defaultBufferLength',
          labelFr: 'distance minimale inter-bâtiments par défaut',
          labelEn: 'min distance between buildings by default',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'bufferLengthWithWindowsOnOnlyOneFacade',
          labelFr:
            'distance minimale si une seulement des facades ont des fenêtres',
          labelEn: 'min distance if only one facade has windows',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
        {
          name: 'bufferLengthWithWindowsOnLowestFacade',
          labelFr: 'distance minimale si la façade basse a des fenêtres',
          labelEn: 'min distance if lowest facade has windows',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
        {
          name: 'bufferLengthWithWindowsOnHighestFacade',
          labelFr: 'distance minimale si la façade haute a des fenêtres',
          labelEn: 'min distance if highest facade has windows',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
        {
          name: 'bufferLengthWithWindowsOnBothFacades',
          labelFr: 'distance minimale les deux facades ont des fenêtres',
          labelEn: 'min distance if both facades windows',
          type: 'function',
          specificArguments: ['hThis', 'hOther', 'hMax', 'hMin'],
          value: null,
        },
        {
          name: 'minHorizontalWindowSize',
          labelFr: 'Taille horizontale 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: 'onlyOnEdgeCenter',
          labelFr: 'Recul mesuré seulement au centre de la façade',
          labelEn: 'Setback measured only from edge center',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyNonHabitat',
          labelFr: 'seulement si deux bâtiments non-habitation',
          labelEn: '',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyOneHabitat',
          labelFr: 'seulement si un bâtiment habitation',
          labelEn: '',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },

    // Edge
    {
      name: 'hasBalconies',
      labelFr: 'A des balcons',
      labelEn: 'Has balconies',
      retro: 'possède un ou des balcons',
      category: 'unaryOperator',
      inputTypes: ['edge'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Window
    {
      name: 'hasDirectView',
      labelFr: 'A une vue directe',
      labelEn: 'Has direct view',
      retro: 'possède une vue directe sur les parcelles voisines',
      category: 'unaryOperator',
      inputTypes: ['window'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isMainWindow',
      labelFr: 'Est une baie principale',
      labelEn: 'Is main window',
      retro: 'est une baie principale',
      category: 'unaryOperator',
      inputTypes: ['window'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Height
    {
      name: 'altitudeReference',
      labelFr: 'Référence de hauteur',
      labelEn: 'Altitude reference',
      retro: 'compté à partir de la réference @',
      category: 'unaryOperator',
      inputTypes: ['height', 'maximalHeight'],
      outputType: 'height',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'indexOfReference',
          labelFr: 'index de la réference de hauteur (1,2,3,4)',
          labelEn: 'ground level before construction',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'graphicalRequirementLabel',
          labelFr: 'label de la prescription graphique (pour index 4)',
          labelEn: 'label of the graphical requirement(for index 4)',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
    },

    // Maximal Height
    {
      name: 'bestHeightOnCorner',
      labelFr:
        'En cas de croisement prendre la voie la plus avantageuse sur Xm',
      labelEn: 'Height bonus around crossroads',
      retro:
        'en prenant, en cas de croisement, la voie la plus avantageuse sur @ mètres',
      category: 'unaryOperator',
      inputTypes: ['maximalHeight'],
      outputType: 'maximalHeight',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'radiusAroundCorner',
          labelFr: 'Distance depuis coin',
          labelEn: 'Radius around the corner',
          type: 'function',
          specificArguments: ['minRoadWidth'],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'heightBonusOnCrossRoads',
      labelFr: 'Bonus de hauteur en cas de croisement',
      labelEn: 'Height bonus around crossroads',
      retro:
        'en rajoutant, en cas de croisement, un bonus dans un rayon autour du coin',
      category: 'unaryOperator',
      inputTypes: ['maximalHeight'],
      outputType: 'maximalHeight',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'heightBonusProportion',
          labelFr: 'Bonus de hauteur (<1)',
          labelEn: 'Height bonus (<1)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'radiusAroundCorner',
          labelFr: 'Distance depuis coin',
          labelEn: 'Radius around the corner',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'heightBonusMeters',
          labelFr: 'Bonus de hauteur (m) ',
          labelEn: 'Height bonus (m)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },

    // Line
    {
      name: 'lineLength',
      labelFr: 'Longueur totale',
      labelEn: 'Total ine length',
      retro: 'longueur totale de',
      category: 'unaryOperator',
      inputTypes: ['line', 'edge', 'linearRequirement', 'border'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Level
    {
      name: 'floorNumber',
      labelFr: 'Numéro du niveau',
      labelEn: 'Floor number',
      retro: 'numéro de niveau de',
      category: 'unaryOperator',
      inputTypes: ['level'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Number
    {
      name: 'troncate',
      labelFr: "Arrondi à l'inférieur",
      labelEn: 'Truncation',
      retro: "arrondi à l'inférieur de",
      category: 'unaryOperator',
      inputTypes: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'listSum',
      labelFr: 'Somme de liste',
      labelEn: 'List sum',
      deprecated: true,
      retro: 'somme des éléments de',
      category: 'unaryOperator',
      inputTypes: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'listMax',
      labelFr: 'Maximum de liste',
      labelEn: 'List maximum',
      deprecated: true,
      retro: 'maximum des éléments de',
      category: 'unaryOperator',
      inputTypes: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'listMin',
      labelFr: 'Minimum de liste',
      labelEn: 'List minimum',
      deprecated: true,
      retro: 'minimum des éléments de',
      category: 'unaryOperator',
      inputTypes: ['number', 'height', 'maximalHeight'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Parcel
    {
      name: 'isAngle',
      labelFr: 'est en angle',
      labelEn: 'is an angle',
      retro: 'cette parcelle est en angle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'goesThrough',
      labelFr: 'est traversante',
      labelEn: 'goes through',
      retro: 'cette parcelle est traversante',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'zoning',
      labelFr: 'Zonage',
      labelEn: 'Zoning',
      retro: 'le zonage de cette parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'zoning',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'parcelBorderByType',
      labelFr: 'Bordure par type',
      labelEn: 'Parcel border by type',
      retro: 'la bordure @ de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'border',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [
        {
          name: 'front',
          labelFr: 'publique',
          labelEn: 'front',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'side',
          labelFr: 'latérale',
          labelEn: 'side',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'back',
          labelFr: 'arrière',
          labelEn: 'back',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'backComputationMethod',
          labelFr: 'index méthode pour distinguer bordures arrières',
          labelEn: 'index of back limits computation method',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'linearGraphicRequirements',
      labelFr: 'Prescriptions graphiques linéaires',
      labelEn: 'Linear graphic requirements',
      retro: 'la prescription linéaire @',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'linearRequirement',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'linearGraphicalRequirementLabel',
          labelFr: 'label de la prescription graphique',
          labelEn: 'label of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
        {
          name: 'linearGraphicalRequirementType',
          labelFr: 'type de la prescription graphique',
          labelEn: 'type of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'surfaceGraphicRequirements',
      labelFr: 'Prescriptions graphiques surfaciques',
      labelEn: 'Surface graphic requirements',
      retro: 'la prescription surfacique @',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'surfaceRequirement',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'surfaceGraphicalRequirementLabel',
          labelFr: 'label de la prescription graphique',
          labelEn: 'label of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
        {
          name: 'surfaceGraphicalRequirementType',
          labelFr: 'type de la prescription graphique',
          labelEn: 'type of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'pointGraphicRequirements',
      labelFr: 'Prescriptions graphiques ponctuelles',
      labelEn: 'Point graphic requirements',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'geomObject',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'pointGraphicalRequirementLabel',
          labelFr: 'label de la prescription graphique',
          labelEn: 'label of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
        {
          name: 'pointGraphicalRequirementType',
          labelFr: 'type de la prescription graphique',
          labelEn: 'type of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'constructibilityBands',
      labelFr: 'bandes de constructibilité',
      labelEn: 'constructibility bands',
      retro:
        'La bande de constructibilité définie par @ prise à partir de la bordure publique de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel', 'border'],
      outputType: 'constructibilityBand',
      inputCanBeList: true,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'stopDepth',
          labelFr: 'profondeur fin',
          labelEn: 'ending depth',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'startDepth',
          labelFr: 'profondeur début',
          labelEn: 'starting depth',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'surfGraphicalRequirementTypes',
          labelFr:
            'types de prescription graphique surf se substituant à la bordure publique',
          labelEn:
            'types of surf. graphic requirements replacing the public limit',
          type: 'text',
          specificArguments: [],
          value: null,
        },
        {
          name: 'linGraphicalRequirementTypes',
          labelFr:
            'types de prescription graphique lin. se substituant à la bordure publique',
          labelEn:
            'types of lin. graphic requirements replacing the public limit',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'constructibilityBandsInM2',
      labelFr: 'bandes de constructibilité en m²',
      labelEn: 'constructibility bands in m²',
      retro:
        "La bande de constructibilité comprennant l'espace @ pris à partir de la bordure publique de la parcelle",
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'constructibilityBand',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'surface',
          labelFr: 'superficie fin',
          labelEn: 'end area',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'surfaceStart',
          labelFr: 'superficie début',
          labelEn: 'starting area',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'dynamicConstructibilityBands',
      labelFr: 'Bandes de constructibilité dynamiques',
      labelEn: 'Dynamic constructibility bands',
      retro:
        "La bande de la parcelle comprennant l'espace @ pris à partir du début du bâtiment",
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'constructibilityBand',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [
        {
          name: 'stopDepth',
          labelFr: 'profondeur fin',
          labelEn: 'ending depth',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        // {
        //     name: 'startDepth',
        //     labelFr: 'profondeur début',
        //     type: 'number',
        //     specificArguments: [],
        // },
      ],
    },
    {
      name: 'constructibilityBandsGraphicDoc',
      labelFr: 'Bandes de constructibilité definie par document graphique',
      labelEn: 'Constructibility bands defined by graphic document',
      retro:
        'La bande de constructibilité définie à partir des documents graphiques',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'constructibilityBand',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'surfaceGraphicalRequirementLabel',
          labelFr: 'label de la prescription graphique',
          labelEn: 'label of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
        {
          name: 'surfaceGraphicalRequirementType',
          labelFr: 'type de la prescription graphique',
          labelEn: 'type of the graphic requirement',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
    },
    //never used, can be deleted
    {
      name: 'isInMaximalCoverageEnvelope',
      labelFr: 'est dans le gabarit couché',
      labelEn: 'is inside maximal coverage envelope',
      deprecated: true,
      retro: 'ce bâtiment est dans le gabarit couché',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'discAroundCorner',
      labelFr: "Disque autour d'un coin",
      labelEn: 'Disc around a corner',
      retro: 'dans un disque autour des coins de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'constructibilityBand',
      inputCanBeList: false,
      outputIsList: true,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'radiusFromCorner',
          labelFr: "Rayon exterieur depuis l'angle",
          labelEn: 'External radius from corner',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'interiorRadiusFromCorner',
          labelFr: "Rayon intérieur depuis l'angle",
          labelEn: 'Internal radius from corner',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'onlyAcuteAngles',
          labelFr: 'Seulement pour angles aigus',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
        {
          name: 'squareInsteadOfDisk',
          labelFr: 'un carré et non un disque',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'lcpLessThan',
      labelFr: 'CES est inférieur à CES maximal',
      labelEn: 'Lot coverage ratio inferior to LCP limit',
      retro: 'a un CES inférieur au CES maximal @',
      category: 'unaryOperator',
      inputTypes: ['parcel', 'constructibilityBand', 'surface'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'lcpLimit',
          labelFr: 'CES maximal',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'minBalconyDepthForFootprint',
          labelFr:
            "Profondeur à partir de laquelle les balcons comptent dans l'empreinte",
          labelEn: 'Min depth starting from which balconies count in footprint',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    //ne prend en compte les empreintes qu'à partir du 1er étage pour artisanat et commerce
    {
      name: 'specialLCPViry',
      labelFr: 'CES spécial Viry',
      labelEn: 'special LCP Viry',
      retro: 'a un CES calculé façon Viry inférieur au CES maximal @',
      category: 'unaryOperator',
      inputTypes: ['parcel', 'constructibilityBand', 'surface'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'lcrLimit',
          labelFr: 'CES maximal',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'maxCESLevelOneInsteadOfFootprint',
      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 a certains usages ',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      deprecated: true,
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'commerce',
          labelFr: 'commerce',
          labelEn: 'commerce',
          type: 'boolean',
          value: null,
        },
        {
          name: 'office',
          labelFr: 'bureaux',
          labelEn: 'office',
          type: 'boolean',
          value: null,
        },
        {
          name: 'workshop',
          labelFr: 'artisanat',
          labelEn: 'workshop',
          type: 'boolean',
          value: null,
        },
        {
          name: 'minProportionOfThisActivity',
          labelFr: 'proportion minimale de ces activitées',
          labelEn: 'min proportion of this activity',
          type: 'number',
          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: 'maxLCR',
          labelFr: 'CES maximal',
          labelEn: 'Maximal LCR',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'hasVisualInterstices', // aubervilliers, faire des percées permet de déroger à la règle 8
      labelFr: 'A au moins N percées visuelles',
      labelEn: 'Has at least N visual interstices',
      deprecated: true,
      retro: 'il y a au moins N @ percées visuelles dans la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'n',
          labelFr: 'N ',
          labelEn: 'N',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'intersticeMinWidth',
          labelFr: 'largeur min des percées',
          labelEn: 'min width of interstice',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'vegetationCoverAreaLimit',
      labelFr: 'Minimum surface espaces verts',
      labelEn: 'Vegetation cover area minimum',
      retro: "contient au moins @ d'espaces verts",
      category: 'unaryOperator',
      inputTypes: ['parcel', 'constructibilityBand', 'surface'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'vegetationAreaMinProportion',
          labelFr: "proportion minimale d'espaces verts (<1)",
          labelEn: 'min proportion of vegetalized parcel area',
          type: 'function',
          specificArguments: ['proportionDeParcelleNonConstruite'],
          value: null,
        },
        {
          name: 'vegetationAreaMin',
          labelFr: "superficie minimale d'espaces verts (en m²)",
          labelEn: 'min surface of vegetalized parcel area',
          type: 'function',
          specificArguments: ['surfaceParcelle'],
          value: null,
        },
      ],
    },
    {
      name: 'vegetationCoverAreaLimitForFrontSpace',
      labelFr:
        'Minimum surface espaces verts pour espace entre bordure publique et bâtiments de premier rang',
      labelEn: 'Vegetation cover area minimum',
      retro: "contient au moins @ d'espaces verts",
      category: 'unaryOperator',
      inputTypes: ['parcel', 'constructibilityBand'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'vegetationAreaMinProportion',
          labelFr: "proportion minimale d'espaces verts (<1)",
          labelEn: 'min proportion of vegetalized area',
          type: 'number',
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'permeableSoilAreaLimit',
      labelFr: 'Minimum pleine terre',
      labelEn: 'Permeable soil area minimum',
      retro: "contient au moins @ d'espaces verts en pleine terre",
      category: 'unaryOperator',
      inputTypes: ['parcel', 'constructibilityBand', 'surface'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'permeableAreaMinProportion',
          labelFr: 'proportion minimale de pleine terre',
          labelEn: 'min proportion of permeable parcel area',
          type: 'function',
          specificArguments: [
            'proportionDeParcelleNonConstruite',
            'proportionParcelleDedieeVert',
          ],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'complexVegetationCoverAreaLimit',
      labelFr: 'Limite complexe espaces verts',
      labelEn: 'Complex vegetation cover area limit',
      retro:
        "contient proportion minimale d'espace verts pondérée différement selon sa nature @",
      category: 'unaryOperator',
      inputTypes: ['parcel', 'constructibilityBand', 'surface'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'vegetationAreaMinProportion',
          labelFr: "proportion minimale d'espace verts",
          labelEn: 'min proportion of vegetalized parcel area',
          type: 'function',
          specificArguments: ['proportionDeParcelleNonConstruite'],
          value: null,
        },
        {
          name: 'permeableSoilCoefficient',
          labelFr: 'coefficient à appliquer aux plantations en pleine terre',
          labelEn: 'coefficient to be applied to permeable soil',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'roofVegetationCoefficient',
          labelFr: 'coefficient à appliquer aux toits végétalisés',
          labelEn: 'coefficient to be applied to vegetalized roofs',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'wallVegetationCoefficient',
          labelFr: 'coefficient à appliquer aux murs végétalisés',
          labelEn: 'coefficient to be applied to vegetalized walls',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'vegetationOnSlabCoefficient1',
          labelFr: 'coefficient 1 à appliquer aux plantations sur dalle',
          labelEn: 'coefficient 1 to be applied to vegetation on slab',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [
        {
          name: 'soilDepth1',
          labelFr: 'profondeur 1 ',
          labelEn: 'depth 1',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'vegetationOnSlabCoefficient2',
          labelFr: 'coefficient 2 à appliquer aux plantations sur dalle',
          labelEn: 'coefficient 2 to be applied to vegetation on slab',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'soilDepth2',
          labelFr: 'profondeur 2',
          labelEn: 'depth 2',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'vegetationOnSlabCoefficient3',
          labelFr: 'coefficient 3 à appliquer aux plantations sur dalle',
          labelEn: 'coefficient 3 to be applied to vegetation on slab',
          type: 'number',
          specificArguments: [],
          value: null,
        },
        {
          name: 'soilDepth3',
          labelFr: 'profondeur 3 (la plus petite)',
          labelEn: 'depth 3 (the smallest)',
          type: 'number',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'maxDepthOfParcel',
      labelFr: 'Profondeur max de la parcelle',
      labelEn: 'Maximal depth of parcel',
      retro: 'La profondeur maximale de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'aroundBuilding',
          labelFr: 'au niveau de Ce bâtiment',
          labelEn: 'around This Building',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'minDepthOfParcel',
      labelFr: 'Profondeur min de la parcelle',
      labelEn: 'Minimal depth of parcel',
      retro: 'La profondeur minimale de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'aroundBuilding',
          labelFr: 'au niveau de Ce bâtiment',
          labelEn: 'around This Building',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'maxWidthOfParcel',
      labelFr: 'Largeur max de la parcelle',
      labelEn: 'Maximal width of parcel',
      retro: 'La largeur maximale de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'aroundBuilding',
          labelFr: 'au niveau de Ce Bâtiment',
          labelEn: 'around This Building',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'minWidthOfParcel',
      labelFr: 'Largeur min de la parcelle',
      labelEn: 'Minimal width of parcel',
      retro: 'la largeur minimale de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'aroundBuilding',
          labelFr: 'au niveau de Ce Bâtiment',
          labelEn: 'around This Building',
          type: 'boolean',
          specificArguments: [],
          value: null,
        },
      ],
    },
    {
      name: 'minDepthOfBlock',
      labelFr:
        "Profondeur minimale de l'îlot perpendiculairement à la bordure publique",
      labelEn: "Block's minimal depth perpendicularly to public border",
      retro:
        'La largeur minimale perpendiculairement à la bordure publique de la parcelle',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'number',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // only used in Romainville UZ
    // « Surface Végétalisée Pondérée » qui doit représenter au minimum, en fonction de la
    // destination des constructions :
    //     - Habitat et hébergement hôtelier : 50% de la surface de l’unité foncière
    // - Bureaux et Constructions et Installations Nécessaires aux Services Publics ou d’Intérêt
    // Collectif : 30% de la surface l’unité foncière
    // - Industrie, artisanat, commerce et entrepôt : 20% de la surface de l’unité foncière
    // Dans le cas d’une unité foncière avec plusieurs destinations des constructions non
    // assujetties à la même proportion obligatoire de « Surface Végétalisée Pondérée », la
    // règle appliquée est celle correspondant à la destination majoritaire en surface de
    // plancher des constructions de l’opération.
    {
      name: 'rule13CustomRomainville',
      labelFr: 'règle 13 spéciale Romainville UZ',
      labelEn: 'rule 13 custom for Romainville UZ',
      retro: 'respecte la règle 13 spéciale Romainville',
      category: 'unaryOperator',
      inputTypes: ['parcel'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Linear graphic requirement
    {
      name: 'data1',
      labelFr: 'Donnée numérique 1',
      labelEn: 'Data 1',
      deprecated: true,
      category: 'unaryOperator',
      inputTypes: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'data2',
      labelFr: 'Donnée numérique 2',
      labelEn: 'Data 2',
      deprecated: true,
      category: 'unaryOperator',
      inputTypes: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'maxData1',
      labelFr: 'Donnée numérique 1 maximale',
      labelEn: 'Data 1 max',
      category: 'unaryOperator',
      inputTypes: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'maxData2',
      labelFr: 'Donnée numérique 2 maximale',
      labelEn: 'Data 2 max',
      category: 'unaryOperator',
      inputTypes: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minData1',
      labelFr: 'Donnée numérique 1 minimale',
      labelEn: 'Data 1 min',
      category: 'unaryOperator',
      inputTypes: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'minData2',
      labelFr: 'Donnée numérique 2 minimale',
      labelEn: 'Data 2 min',
      category: 'unaryOperator',
      inputTypes: ['linearRequirement', 'surfaceRequirement'],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    // never used
    // {
    //   name: 'width',
    //   labelFr: 'Largeur',
    //   labelEn: 'Width',
    //   deprecated: true,
    //   category: 'unaryOperator',
    //   inputTypes: ['linearRequirement'],
    //   outputType: 'number',
    //   inputCanBeList: true,
    //   outputIsList: false,
    //   obligatoryParameters: [],
    //   nonObligatoryParameters: [],
    // },

    // Surface
    {
      name: 'partOfThisBuildingInSurface',
      labelFr: 'Partie du bâtiment courant située DANS la surface',
      retro: 'partie du bâtiment courant située dans la surface',
      labelEn: 'Part of This Building in the surface',
      category: 'unaryOperator',
      inputTypes: ['constructibilityBand', 'surface', 'surfaceRequirement'],
      outputType: 'building',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'partOfThisBuildingOutsideSurface',
      labelFr: 'Partie du bâtiment courant située HORS de la surface',
      retro: 'partie du bâtiment courant située hors de la surface',
      labelEn: 'Part of This Building outside the surface',
      category: 'unaryOperator',
      inputTypes: ['constructibilityBand', 'surface', 'surfaceRequirement'],
      outputType: 'building',
      pro: true,
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },
    {
      name: 'isUnconstructible',
      labelFr: 'Est inconstructible',
      retro: 'est inconstructible',
      labelEn: 'Is unconstructible',
      category: 'unaryOperator',
      inputTypes: [
        'constructibilityBand',
        'surface',
        'surfaceRequirement',
        'parcel',
      ],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'explanation',
          labelFr: 'Explication',
          retro: 'explication',
          labelEn: 'explanation',
          type: 'text',
          value: null,
        },
      ],
    },
    // will guide PLU auto to occupy them completely
    {
      name: 'isConstructible',
      labelFr: 'Est une surface constructible contraignante',
      retro: "est une zone d'empreintes constructible contraignante",
      labelEn: 'Is constructible',
      category: 'unaryOperator',
      inputTypes: ['constructibilityBand', 'surface', 'surfaceRequirement'],
      outputType: 'boolean',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [
        {
          name: 'explanation',
          labelFr: 'Explication',
          retro: 'explication',
          labelEn: 'explanation',
          type: 'text',
          value: null,
        },
      ],
    },
    {
      name: 'area',
      labelFr: 'superficie (m²)',
      labelEn: 'area (m²)',
      retro: 'la superficie de',
      category: 'unaryOperator',
      inputTypes: [
        'footprint',
        'surface',
        'constructibilityBand',
        'parcel',
        'surfaceRequirement',
      ],
      outputType: 'number',
      inputCanBeList: true,
      outputIsList: false,
      obligatoryParameters: [],
      nonObligatoryParameters: [],
    },

    // Message
    {
      name: 'warning',
      labelFr: 'Avertissement',
      retro: "afficher message d'avertissement",
      labelEn: 'Warning',
      category: 'unaryOperator',
      inputTypes: ['message'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'warningText',
          labelFr: 'Texte',
          labelEn: 'Texte',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    {
      name: 'errorMesssage',
      labelFr: "Message d'erreur",
      retro: "afficher message d'erreur",
      labelEn: 'Error message',
      category: 'unaryOperator',
      inputTypes: ['message'],
      outputType: 'boolean',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'errorText',
          labelFr: 'Texte',
          labelEn: 'Texte',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
    // ZoneToBe
    {
      name: 'aZoning',
      labelFr: 'Nom du zonage',
      retro: 'le zonage ',
      labelEn: 'Zoning by name',
      category: 'unaryOperator',
      inputTypes: ['zoneToBe'],
      outputType: 'zoning',
      inputCanBeList: false,
      outputIsList: false,
      obligatoryParameters: [
        {
          name: 'zoneName',
          labelFr: 'Nom du zonage',
          retro: 'nom',
          labelEn: 'Name of the zone',
          type: 'text',
          specificArguments: [],
          value: null,
        },
      ],
      nonObligatoryParameters: [],
    },
  ],
};

export default unaryOperator;