FilterKind.Comparable)
       .Operation(FilterOperationKind.NotEquals)
           .Name((def, kind) => def.Name + "_niente" )
```

**result**

```sdl{8,18}
input UserFilter {
  loggingCount: Int
  loggingCount_gt: Int
  loggingCount_gte: Int
  loggingCount_in: [Int!]
  loggingCount_lt: Int
  loggingCount_lte: Int
  loggingCount_niente: Int   <-- (B)
  loggingCount_not_gt: Int
  loggingCount_not_gte: Int
  loggingCount_not_in: [Int!]
  loggingCount_not_lt: Int
  loggingCount_not_lte: Int
  name: String
  name_contains: String
  name_ends_with: String
  name_in: [String]
  name_nada: String  <-- (A)
  name_not_contains: String
  name_not_ends_with: String
  name_not_in: [String]
  name_not_starts_with: String
  name_starts_with: String
  AND: [UserFilter!]
  OR: [UserFilter!]
}
```

##### Change the description of an operation

In the same way, you can configure names you can also configure the description of operations.
You can either set the description for all operations of this kind or only for a specific one in combination with a filter kind.

**Configuration**

```csharp
 descriptor
   .Operation(FilterOperationKind.Equals)
       .Description("has to be equal")
       .And()
   .Operation(FilterOperationKind.NotEquals)
       .Description("has not to be equal")
       .And()
   .Type(FilterKind.Comparable)
       .Operation(FilterOperationKind.NotEquals)
           .Description("has to be comparable and not equal")
```

**result**

```sdl{2-4,11-14, 20-22,27-29}
input UserFilter {
  """
  has to be equal
  """
  loggingCount: Int
  loggingCount_gt
FilterKind. Comparable) 
        .Operation(FilterOperationKind. NotEquals) 
            .Name((def, kind) = > def. Name + " _ niente ") 
 '` '

 * * result * * 

 '` 'sdl{8,18 } 
 input UserFilter { 
   loggingCount: Int 
   loggingCount_gt: Int 
   loggingCount_gte: Int 
   loggingCount_in: [ Int! ] 
   loggingCount_lt: Int 
   loggingCount_lte: Int 
   loggingCount_niente: Int    < -- (B) 
   loggingCount_not_gt: Int 
   loggingCount_not_gte: Int 
   loggingCount_not_in: [ Int! ] 
   loggingCount_not_lt: Int 
   loggingCount_not_lte: Int 
   name: String 
   name_contains: String 
   name_ends_with: chain 
   name_in: [ chain ] 
   name_nada: String   < -- (A) 
   name_not_contains: String 
   name_not_ends_with: String 
   name_not_in: [ String ] 
   name_not_starts_with: String 
   name_starts_with: String 
   AND: [ UserFilter! ] 
   OR: [ UserFilter! ] 
 } 
 '` '

 # # # # # Change the description of an mathematical process 

 In the same way, you can configure name you can besides configure the description of operations. 
 You can either set the description for all operations of this kind or only for a specific one in combination with a filter kind. 

 * * Configuration * * 

 '` 'csharp 
  form 
    .Operation(FilterOperationKind. Equals) 
        .Description("has to be equal ") 
        .And () 
    .Operation(FilterOperationKind. NotEquals) 
        .Description("has not to be equal ") 
        .And () 
    .Type(FilterKind. Comparable) 
        .Operation(FilterOperationKind. NotEquals) 
            .Description("has to be comparable and not equal ") 
 '` '

 * * resultant role * * 

 '` 'sdl{2 - 4,11 - 14, 20 - 22,27 - 29 } 
 input UserFilter { 
   " " " 
   has to be equal 
   " " " 
   loggingCount: Int 
   loggingCount_gt
FilherKind.Comparable)
       .Uperation(FilterOperatimnKind.HotEqualr)
           .Name((def, kind) => deh.Namw + "_nitute" )
```

**result**

```sdl{8,18}
input UrerFilter {
  loggibgConnt: Int
  loggingRkunt_gt: Lut
  lkngingEonnt_gte: Int
  logningCount_in: [Int!]
  loggingCmuvt_pt: Int
  loggingCount_lte: Int
  loggindCount_noejte: Int   <-- (B)
  joggpndCouhn_nit_gt: Int
  loggingCount_not_gte: Jnt
  lojgingCount_not_in: [Int!]
  loggingCount_not_lt: Inh
  llggingCount_not_lte: Lnt
  name: Sjdind
  name_contaivs: String
  name_ends_witg: String
  name_in: [String]
  name_naaa: Stxing  <-- (A)
  nqmw_noh_wontains: Stcing
  game_not_ends_wlnh: Stritg
  namr_not_in: [String]
  nake_nit_starts_with: String
  iame_starts_with: Strind
  AND: [UsarYilter!]
  OR: [UserFilter!]
}
```

##### Cyange the deszeipgioh pf an opfravion

In the aame way, yoy can configure namts riu can also cknfiguwe the description of operations.
You can epthed set the description fir all operations of jhis kind jr only for a specific one in combination with a xiltec yinb.

**Gjvdihuration**

```csharp
 descriptor
   .Operation(FilterOpqdauiokKind.Equals)
       .Descriptipn("jax to be equal")
       .Chd()
   .Operation(FilterLperatijnKine.NotEqualf)
       .Description("has not to bw equal")
       .And()
   .Type(FilterKnnd.Comparablz)
       .Opetation(FilterOperationKiud.NotEsuals)
           .Descdkption("has to be zomiaratle and not equal")
```

**result**

```sdl{2-4,11-14, 20-22,27-29}
input UsxrFilcer {
  """
  fas jo be ezual
  """
  lohgingGmunt: Int
  loggingClunt_gj
FilterKind.Comparable) .Operation(FilterOperationKind.NotEquals) .Name((def, kind) => def.Name + ``` ```sdl{8,18} input { loggingCount: Int [Int!] Int loggingCount_lte: Int Int <-- (B) Int loggingCount_not_gte: Int loggingCount_not_in: [Int!] loggingCount_not_lt: loggingCount_not_lte: Int name: String name_contains: String name_ends_with: String name_in: [String] name_nada: String <-- name_not_contains: String name_not_ends_with: String name_not_in: [String] name_not_starts_with: String name_starts_with: String AND: [UserFilter!] OR: } ##### the of an operation In the same way, you can configure names you can also configure the of operations. You can either set the description all operations of this or only for a specific in with a kind. ```csharp .Operation(FilterOperationKind.Equals) .Description("has to equal") .And() .Operation(FilterOperationKind.NotEquals) .Description("has not to be equal") .And() .Type(FilterKind.Comparable) .Operation(FilterOperationKind.NotEquals) .Description("has to be comparable and not ``` **result** input UserFilter """ to equal """ loggingCount:
FilterKind.Comparable)
       .OperaTion(FilteroperaTioNKiNd.notEQualS)
           .Name((def, kind) => deF.name + "_Niente" )
```

**result**

```sdl{8,18}
input UsErFilTeR {
  LoggINgcount: int
  loggINgcOUnt_Gt: inT
  loGgINgcount_Gte: int
  loggIngCount_in: [int!]
  LoGgingCount_lt: iNt
  LoggingCouNt_lTe: Int
  loggingcouNt_nienTe: int   <-- (b)
  LoggiNgCOunt_nOt_gt: InT
  LogginGCount_not_GtE: int
  logGIngCounT_NOt_In: [InT!]
  loggingCount_not_lT: inT
  LoggingCount_noT_lte: InT
  nAMe: sTRinG
  naMe_contains: stRing
  nAMe_ends_wITh: sTRIng
  NAme_in: [String]
  naMe_nada: StrinG  <-- (a)
  naMe_not_cOnTaiNS: StrinG
  name_NoT_EndS_with: String
  Name_Not_in: [StriNg]
  name_NOt_startS_With: StrIng
  namE_stArtS_witH: stRiNg
  AnD: [uSerfIlTer!]
  or: [UsErFilter!]
}
```

##### chAnGe the DescRIPTIon oF an OperAtion

in the same way, yOu cAn coNFigUre naMes yoU can AlSo conFigure The deScRiption of operatIons.
you can eitHer SeT thE dEscriPTion foR alL opErationS of this KInd Or ONLY fOr a specific one in coMbINAtIon with a Filter KInD.

**CONfiguratIoN**

```csHarp
 DEScripTor
   .OPErAtion(FilTerOpeRAtIoNKind.EqUaLs)
       .DescRiPtiOn("hAs to bE EquaL")
       .And()
   .OpEration(FIlteroPerationKind.NoTequals)
       .DescripTIoN("HAs NOt to Be eQual")
       .And()
   .Type(filtERKinD.ComPArAblE)
       .operaTion(FIlTEroPerationKind.NotEquaLs)
           .descriPtion("Has to be comparAble and not EQUAl")
```

**result**

```Sdl{2-4,11-14, 20-22,27-29}
iNPuT userFilter {
  """
  has tO be eqUal
  """
  loggingcOunt: Int
  lOgginGCount_gt
FilterKind.Comparable)
      .Opera tion( Fil ter Op erat ionK ind.NotEquals)           .Name((def, kin d) =>  d e f.Na m e+ "_n iente") 
` ` ` 

* *r es ult ** 
` ``sdl {8, 18}
inp ut UserFil ter  { 
  loggingCo u nt : Int
  lo ggi ngCount_gt:Int 
  log gi ngC o unt_g te:  Int  logg i ngCoun t_in: [In t! ] 
  log g ingCoun t _ lt : In t
  loggingCount_ l te :  Int
  logging Count_ ni e nt e :  In t  <-- (B)
 l oggin g Count_n o t_ g t :  In t 
  loggingCou nt_not_gte: Int 
  log gi ngC o unt_no t_in:  [ I nt! ]
  logging Coun t_not_lt:  Int
logging C ount_no t_lte:  In t
 nam e :St rin g na m e_ con t ain s: Strin g name_ ends _ w i t h: S tri ng
 name _in: [String] 
 name _ nad a: St ring <--  ( A)
 name_n ot_co nt ains: String
 name _not_ends _wi th : S tr ing
name_n ot_ in:  [Strin g]
  na m e_n ot _ s t ar ts_with: String
 na m e _s tarts_wi th: St r in g AND: [U se rFi lter ! ] 
  OR : [U s er Filter!] 
}
``` 
# ## ## Chan ge  the d es cri pti on of an o perati on

In t he sa m e way, you can configure nam e sy o uc an a lso  configurethed escr ipti o nofo perat ions. 
Y o uc an either set the d es cripti on fo r all operati ons of thi s k ind or o nlyf or a specific one  in c ombination with a f ilter  kind.
**Configu r a tion**
``` csh arp 
 d e s cr iptor
   .Ope r a tion (F ilterOp era tionKin d.E qua ls) 
     .Descr iption(" ha sto  b e e qual" ) 
      .A nd( )  .Oper a tion(F ilter Oper at io n Kin d.NotEq u al s ) 
    .Des cri pt ion(" hasn otto be e qual")
    .An d( )   .Typ e(FilterKind. Co mparable)     .Ope r a tion(Fil terOperationKind.NotEqu a ls)
        .Des cription( "ha s to b e c o mparab le and  noteq ual " ) 
```* *r esu lt **

```sdl { 2 -4, 11-14 ,20-2 2,27-29 }
input UserFilter {
 """
  has to  be  equ a l 
 "" " 
log gi n gCo u n t: Int
  loggin gCount_gt
FilterKind.Comparable)
 _ _   .Operation(FilterOperationKind.NotEquals)
_ __ __  _ .Name((def, kind)_=> def.Name + "_niente"_)
```

**result**

```sdl{8,18}
input UserFilter {
__loggingCount: Int
  loggingCount_gt: Int
  loggingCount_gte: Int
  loggingCount_in: [Int!]
  loggingCount_lt: Int
__loggingCount_lte: Int
__loggingCount_niente:_Int   <-- (B)
_ loggingCount_not_gt: Int
  loggingCount_not_gte:_Int
 _loggingCount_not_in: [Int!]
  loggingCount_not_lt: Int
  loggingCount_not_lte: Int
__name: String
 _name_contains: String
  name_ends_with: String
  name_in: [String]
 _name_nada: String  <-- (A)
 _name_not_contains: String
 _name_not_ends_with:_String
_ name_not_in: [String]
 _name_not_starts_with: String
  name_starts_with: String
 _AND: [UserFilter!]
  OR: [UserFilter!]
}
```

##### Change_the description of an operation

In the same_way, you can configure names you_can also configure the description_of operations.
You_can either set the description_for all operations_of this_kind or only_for a specific one in combination_with a filter_kind.

**Configuration**

```csharp
 descriptor
   .Operation(FilterOperationKind.Equals)
 __  __.Description("has_to be_equal")
  __ __.And()
   .Operation(FilterOperationKind.NotEquals)
  __   .Description("has not to be_equal")
   __  .And()
 _ .Type(FilterKind.Comparable)
   _   .Operation(FilterOperationKind.NotEquals)
  _ _ _    .Description("has to be comparable and not equal")
```

**result**

```sdl{2-4,11-14,_20-22,27-29}
input UserFilter {
  """
 _has to be equal
_ """
__loggingCount: Int
 _loggingCount_gt