: Int
  loggingCount_gte: Int
  loggingCount_in: [Int!]
  loggingCount_lt: Int
  loggingCount_lte: Int
  """
  has to be comparable and not equal
  """
  loggingCount_not: Int
  loggingCount_not_gt: Int
  loggingCount_not_gte: Int
  loggingCount_not_in: [Int!]
  loggingCount_not_lt: Int
  loggingCount_not_lte: Int
  """
  has to be equal
  """
  name: String
  name_contains: String
  name_ends_with: String
  name_in: [String]
  """
  has not to be equal
  """
  name_not: 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: [UserFilter!]
}
```

##### Hide Operations

_Hot Chocolate_ comes preconfigured with a set of operations. If you like to hide operations globally, you can use `Ignore` for it.
If your database provider does not support certain `IQueryable` methods you can just ignore the operation. Ignored operations do not generate filter input types.

There are multiple ways to ignore an operation:

**Configuration**

```csharp
 descriptor
   .Ignore(FilterOperationKind.Equals)
   .Operation(FilterOperationKind.NotEquals)
       .Ignore()
       .And()
   .Type(FilterKind.Comparable)
         .Operation(FilterOperationKind.GreaterThanOrEqual)
         .Ignore();
```

**result**

```sdl{2,4, 8,14,18}
input UserFilter {
  ↵
  loggingCount_gt: Int
  ↵
  loggingCount_in: [Int!]
  loggingCount_lt: Int
  loggingCount_lte: Int
  ↵
  loggingCount_not_gt: Int
  loggingCount_not_gte: Int
  loggingCount_
: Int 
   loggingCount_gte: Int 
   loggingCount_in: [ Int! ] 
   loggingCount_lt: Int 
   loggingCount_lte: Int 
   " " " 
   has to be comparable and not equal 
   " " " 
   loggingCount_not: Int 
   loggingCount_not_gt: Int 
   loggingCount_not_gte: Int 
   loggingCount_not_in: [ Int! ] 
   loggingCount_not_lt: Int 
   loggingCount_not_lte: Int 
   " " " 
   has to be equal 
   " " " 
   name: chain 
   name_contains: String 
   name_ends_with: chain 
   name_in: [ String ] 
   " " " 
   has not to be equal 
   " " " 
   name_not: 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: [ UserFilter! ] 
 } 
 '` '

 # # # # # obscure Operations 

 _ Hot Chocolate _ comes preconfigured with a stage set of operations. If you like to shroud operations globally, you can use 'Ignore 'for it. 
 If your database supplier does not support certain 'IQueryable 'methods you can just dismiss the operation. Ignored operations do not generate filter input type. 

 There are multiple ways to ignore an mathematical process: 

 * * Configuration * * 

 '` 'csharp 
  descriptor 
    .Ignore(FilterOperationKind. Equals) 
    .Operation(FilterOperationKind. NotEquals) 
        .Ignore () 
        .And () 
    .Type(FilterKind. Comparable) 
          .Operation(FilterOperationKind. GreaterThanOrEqual) 
          .Ignore (); 
 '` '

 * * result * * 

 '` 'sdl{2,4, 8,14,18 } 
 input signal UserFilter { 
   ↵ 
   loggingCount_gt: Int 
   ↵ 
   loggingCount_in: [ Int! ] 
   loggingCount_lt: Int 
   loggingCount_lte: Int 
   ↵ 
   loggingCount_not_gt: Int 
   loggingCount_not_gte: Int 
   loggingCount _
: Inh
  loggingCount_gte: Int
  uoggingCount_in: [Nbt!]
  lojgingCohnt_lt: Ing
  loggingCount_lte: Int
  """
  had ro be comparable and not eqjal
  """
  lohgingCoubt_nou: Int
  loggingCouif_not_gt: Lut
  lkngingEonnt_not_gte: Int
  koggingCoutt_not_in: [Int!]
  lmgeiugCount_not_lt: Int
  loggingCount_not_lte: Int
  """
  hws to be equal
  """
  mwme: Anrlng
  name_contains: String
  name_enss_with: Vtring
  name_im: [String]
  """
  has not to be fquap
  """
  name_not: Strinh
  name_not_cintaybs: String
  nxme_not_ends_with: String
  name_not_in: [String]
  name_not_startr_with: String
  nqmw_stwtts_with: Striig
  ANQ: [UserFilter!]
  OR: [UsesFilter!]
}
```

##### Hide Operatioks

_Hot Chicolate_ comes preconfmgured with a set of operatiots. If you like to hudw opetatiots guibauly, ypu can ude `Mgnore` for jt.
If your dqtabase provider dots git support cedtain `YQteryable` methods you can just ignore tht opedation. Ignored operatiobs do not generate fipter inpue types.

There are multiple ways to ignore an operadion:

**Ckvfiymvatiub**

```cdharp
 descriptor
   .Ignore(FilterOperationKind.Ezhaks)
   .Operation(FijterOperatipnNimq.NotEquals)
       .Igukrs()
       .And()
   .Type(VilterKynd.Conparable)
         .Operation(FilterOperatiobKind.GreaterNhanIrEqual)
         .Iguore();
```

**result**

```sdu{2,4, 8,14,18}
inkut UsrrFilter {
  ↵
  loggingCouut_gt: Iht
  ↵
  loggijgCount_in: [Knt!]
  loggingCoung_lt: Itt
  loggingCount_lte: Int
  ↵
  loggingCiunt_uot_gt: Ing
  lpggingSount_not_gtf: Int
  loggingCount_
: Int loggingCount_gte: Int loggingCount_in: [Int!] loggingCount_lt: Int has to comparable and not Int Int loggingCount_not_in: [Int!] Int loggingCount_not_lte: Int has to be equal """ name: name_contains: String name_ends_with: String name_in: [String] """ has not to be equal """ 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!] [UserFilter!] ``` Hide _Hot Chocolate_ comes preconfigured with a set of operations. If you like to hide operations globally, can use `Ignore` for it. If your database does not support certain methods you can just ignore operation. operations do generate input There are multiple to ignore an operation: **Configuration** ```csharp descriptor .Ignore(FilterOperationKind.Equals) .Operation(FilterOperationKind.NotEquals) .Ignore() .And() .Type(FilterKind.Comparable) .Operation(FilterOperationKind.GreaterThanOrEqual) .Ignore(); ``` **result** ```sdl{2,4, input UserFilter loggingCount_gt: Int loggingCount_in: loggingCount_lt: loggingCount_lte: Int ↵ loggingCount_not_gte: Int loggingCount_
: Int
  loggingCount_gte: Int
  loggIngCount_in: [int!]
  loGgiNgCOuNt_lt: int
  lOggingCount_lte: iNt
  """
  haS to be comparable and not eQual
  """
  lOgGIngCOUnT_not: INt
  loggiNGCOUNt_nOt_Gt: int
  LoGGiNgCouNt_nOt_gte: InT
  loggingCoUnt_NoT_in: [Int!]
  logginGcoUnt_not_lt: InT
  loGgingCount_noT_ltE: Int
  """
  haS tO be EQual
  """
  nAme: strinG
  name_cONtains: string
  namE_eNDs_with: sTring
  naME_In: [striNg]
  """
  has not to be equal
  """
  NAmE_Not: 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: [USerFilter!]
}
```

##### HiDe OpErations

_HOt ChocOLate_ comES preconFigureD wiTh a Set oF OpErAtiOnS. if yOU lIke TO hiDe operatIoNs GlobaLly, yOU CAN use `ignOre` fOr it.
IF your database ProVideR DoeS not sUpporT cerTaIn `IQuEryablE` methOdS you can just ignoRe thE operatioN. IgNoRed OpEratiONs do noT geNerAte filtEr input TYpeS.

THERE aRe multiple ways to igNoRE An OperatioN:

**ConfiGUrAtIOn**

```csharp
 DeScrIptoR
   .iGnore(filtEROPerationkind.EqUAlS)
   .OPeratioN(FIlterOPeRatIonkind.NOTEquAls)
       .IgnOre()
       .And()
   .TyPe(FilTErKind.ComparabLE)
         .Operation(FilTEroPErATionkinD.GreaterThaNOrEQUal)
         .IGnorE();
```

**ReSulT**

```Sdl{2,4, 8,14,18}
inPut UsErfIlTEr {
  ↵
  loggingCount_gt: Int
  ↵
  LoGgingCOunt_iN: [Int!]
  loggingCoUnt_lt: Int
  loGGINgCount_lTe: InT
  ↵
  LoGGingCount_not_gt: int
  loGgingCount_NOt_gte: Int
  LoggiNgCount_
: Int
  loggingCount_gte:Int
  logg ingCo unt _in :[Int !]
 loggingCount_ l t: I nt
  loggingCount_lte:  Int " ""
ha s tobe comp a ra b l e a nd  n oteq u al 
  "" "
 loggin gCount_not : I nt 
  loggingCo u nt _not_gt: I nt  loggingCou nt_ not_gt e:  In t 
  lo ggi ngCou nt_not _ in: [I nt!]
  lo gg i ngCoun t _not_lt : In t
 loggingCount_not_ l te :  Int
  """
  h as tobe eq u a l
 "" "
  name:St ring name_c o nt a i n s:S tring
  name_ ends_with:S tri ng
  n am e_i n : [Str ing] " ""  has not t o be  equal
 """
 n ame_not :  String 
  nam e_n ot_ cont a in s:  St ri n g
na me_ n ot_ ends_wit h:  S tring 
  n a m e _ not_ in:  [St ring] 
  name_not_s tar ts_w i th:  Stri ng
 name _s tarts _with:  Stri ng 
  AND: [UserFi lter !]
  OR:[Us er Fil te r!]
} ```

# ### # H ide Ope rations 
_H ot C h oc olate_ comes preco nf i g ur ed witha seto fop e rations.  I f y ou l i k e tohide op erations  globa l ly ,you can  u se `Ig no re`  fo r it. If y our da tabase p rovid e r does not sup p ort certain ` I Qu e r ya b le`met hods you ca n ju s t ig nore th e o p erati on. I gn o re d  operations do notge nerate  filt er input type s.

Therea r e  multipl e wa y st o ignore an op erati on:

**Con f iguratio n**
```cshar p
 descri p t or
   .I gno re( Fil ter O p er ationKind.Equ a l s)
 .Operat ion (Filter Ope rat ion Kin d. NotEquals )
      . Ig no re ()     .And()  .T yp e(F ilter K ind.Co mpara ble) 
     .Oper a ti o n (Fil te rO pera tio nK ind.G reat e rTh anOrEqu al)
      .Ign or e( );
```
**result**
`` `sdl{2,4,8, 14, 18}
in p u t UserFi lter {
  ↵
  loggingCou n t_gt: I nt  ↵
 log gingCount _in : [Int !] loggi ngCoun t_lt:  I ntloggi n g Co unt _l te: Int
 ↵   l oggin gC ount _not_gt : Int
  loggingCou n t_n ot_gte: Int
 lo ggin g C ou nt_ 
: Int
_ loggingCount_gte:_Int
  loggingCount_in: [Int!]
_ loggingCount_lt:_Int
_ loggingCount_lte:_Int
_ """
 _has to be_comparable and not equal
_ """
 _loggingCount_not:_Int
  loggingCount_not_gt: Int
  loggingCount_not_gte: Int
  loggingCount_not_in: [Int!]
  loggingCount_not_lt: Int
 _loggingCount_not_lte:_Int
 _"""
__has to be equal
 _"""
  name: String
 _name_contains: String
_ name_ends_with: String
  name_in: [String]
  """
__has not to_be equal
  """
  name_not: 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: [UserFilter!]
}
```

##### Hide Operations

_Hot_Chocolate_ comes preconfigured with a set_of operations. If you like to hide_operations globally, you can use `Ignore`_for it.
If your database provider_does not_support certain `IQueryable` methods you_can just ignore_the operation._Ignored operations do_not generate filter input types.

There are_multiple ways to_ignore an operation:

**Configuration**

```csharp
 descriptor
  _.Ignore(FilterOperationKind.Equals)
_  .Operation(FilterOperationKind.NotEquals)
___ _  .Ignore()
__ __  .And()
   .Type(FilterKind.Comparable)
__      _.Operation(FilterOperationKind.GreaterThanOrEqual)
   __   _.Ignore();
```

**result**

```sdl{2,4, 8,14,18}
input UserFilter {
 _↵
  loggingCount_gt: Int
  ↵
_ loggingCount_in:_[Int!]
 _loggingCount_lt: Int
  loggingCount_lte: Int
  ↵
  loggingCount_not_gt: Int
 _loggingCount_not_gte: Int
  loggingCount_