# Filtering

## Generics

<mark style="color:green;">`<T>`</mark> represents the object's shape coming from the data source.

<mark style="color:green;">`<R>`</mark> represents the column data type: <mark style="color:green;">`string`</mark>, <mark style="color:green;">`number`</mark>, <mark style="color:green;">`Date`</mark>, or <mark style="color:green;">`boolean`</mark>.

<mark style="color:green;">`<V>`</mark> represents the filter values.

<mark style="color:green;">`<M>`</mark> represents the filter selection model: <mark style="color:green;">`DikeSelectionModel`</mark>.

## DikeFilterCondition\<T, R, V>

```typescript
abstract class DikeFilterCondition<T extends object, R extends string | number | Date | boolean, V> {
  protected indexConditions: FilterCondition<T, R, V>;

  constructor();

  get conditions(): Condition<T, R, V>[];

  assign(filterConditions: DikeFilterCondition<T, R, V>): this;  
  addCondition(condition: Condition<T, R, V>): this;
  removeCondition(name: string): Condition<T, R, V>;
  getCondition(name: string): Condition<T, R, V>;
}
```

## DikeSelectionFilterCondition\<M, T, R, V>

```typescript
abstract class DikeSelectionFilterCondition<M, T extends object, R extends string | number | Date | boolean, V> extends DikeFilterCondition<T, R, V> {
  protected dikeFilterOptions: M[];

  constructor();

  abstract set options(options: M[]);
  abstract get options(): M[];

  assign(value: DikeSelectionFilterCondition<M, T, R, V>): this;
  addCondition(condition: Condition<T, R, V>): this;

  protected isValidCondition(name: string): boolean;
}
```

## DikeBinarySelectionFilterCondition\<M, T, V>

```typescript
abstract class DikeBinarySelectionFilterCondition<M, T extends object, V> extends DikeSelectionFilterCondition<M, T, string | number | boolean, V> {
  private MAX_OPTIONS: number = 2;

  constructor();

  set options(options: M[]);
  get options(): M[];

  assign(value: DikeBinarySelectionFilterCondition<M, T, V>): this;
}
```

## CustomBinaryFilterCondition\<T>

```typescript
class CustomBinaryFilterCondition<T extends object> extends DikeBinarySelectionFilterCondition<DikeBinarySelectionModel, T, DikeBinaryFilter> {
  constructor();

  addExistingCondition(name: string): this;
}
```

## DikeMultipleSelectionFilterCondition\<M, T, R, V>

```typescript
abstract class DikeMultipleSelectionFilterCondition<M, T extends object, R extends string | number | boolean | Date, V> extends DikeSelectionFilterCondition<M, T, R, V> {
  constructor();

  set options(options: M[]);
  get options(): M[];
  
  assign(value: DikeSelectionFilterCondition<M, T, R, V>): this;
}
```

## CustomTextCaseFilterCondition\<T>

```typescript
class CustomTextCaseFilterCondition<T extends object> extends DikeFilterCondition<T, string, DikeTextCaseFilter> {
  constructor();

  addExistingCondition(name: string): this;
  protected isValidCondition(name: string): boolean;
}
```

## CustomRowTextCaseFilterCondition\<T>

```typescript
class CustomRowTextCaseFilterCondition<T extends object> extends CustomTextCaseFilterCondition<T> {
  constructor();

  addCondition(condition: Condition<T, string, DikeTextCaseFilter>): this;
}
```

## CustomNumericFilterCondition\<T>

```typescript
class CustomNumericFilterCondition<T extends object> extends DikeFilterCondition<T, number, DikeNumericFilter> {
  constructor();

  addExistingCondition(name: string): this;
  protected isValidCondition(name: string): boolean;
}
```

## CustomRowNumericFilterCondition\<T>

```typescript
class CustomRowNumericFilterCondition<T extends object> extends CustomNumericFilterCondition<T> {
  constructor();

  addCondition(condition: Condition<T, number, DikeNumericFilter>): this;
  protected isValidCondition(name: string): boolean;
}
```

## CustomDateFilterCondition\<T>

```typescript
class CustomDateFilterCondition<T extends object> extends DikeFilterCondition<T, string | number | Date, DikeDateFilter> {
  constructor();

  addExistingCondition(name: string): this;
  protected isValidCondition(name: string): boolean;
}
```

## CustomRowDateFilterCondition\<T>

```typescript
class CustomRowDateFilterCondition<T extends object> extends CustomDateFilterCondition<T> {
  constructor();

  addCondition(condition: Condition<T, string | number | Date, DikeDateFilter>): this;
  protected isValidCondition(name: string): boolean;
}
```

## CustomMultipleTextFilterCondition\<T>

```typescript
class CustomMultipleTextFilterCondition<T extends object> extends DikeMultipleSelectionFilterCondition<DikeTextSelectionModel, T, string, DikeTextFilter>  {
  constructor();
    
  addExistingCondition(name: string): this
}
```

## CustomMultipleNumericFilterCondition\<T>

```typescript
class CustomMultipleNumericFilterCondition<T extends object> extends DikeMultipleSelectionFilterCondition<DikeNumericSelectionModel, T, number, DikeNumericFilter>  {

  constructor();
  
  addExistingCondition(name: string): this;
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.dikesoft.com/reference/classes/filtering.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
