CipherStashDocs
ReferenceStack SDKAPI reference

eql/v3

eql/v3 is a module in @cipherstash/stack. TypeScript API reference with its signature, parameters, and usage.

@cipherstash/stack


eql/v3

Classes

EncryptedTextSearchColumn

Defined in: eql/v3/columns.ts:540

Builder for a public.eql_v3_text_search column.

The concrete type inherently enables equality + order/range + free-text match — there are no capability-enabling or tuning methods. The match index is always emitted with the default configuration.

NOTE — querying: a text_search column emits all three indexes (unique, ope, match), and the shared index-inference picks them by fixed priority unique > match > ordering. So encryptQuery(value, { column, table }) with NO explicit queryType builds an EQUALITY term (via unique), NOT a free-text match — a substring like 'joh' then matches nothing. To run a free-text match query you MUST pass queryType: 'freeTextSearch':

// equality (default): exact value only
client.encryptQuery('[email protected]', { column: users.email, table: users })
// free-text match: substring/token search
client.encryptQuery('joh', { column: users.email, table: users, queryType: 'freeTextSearch' })

Extends

Constructors

Constructor
new EncryptedTextSearchColumn(columnName): EncryptedTextSearchColumn;

Defined in: eql/v3/columns.ts:543

Parameters
columnName

string

Returns

EncryptedTextSearchColumn

Overrides

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_text_search";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_text_search"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: true;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: true;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: true = true;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedIntegerColumn

Defined in: eql/v3/columns.ts:559

Extends

Constructors

Constructor
new EncryptedIntegerColumn(columnName, definition): EncryptedIntegerColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_integer" = 'public.eql_v3_integer'

castAs

"number" = 'number'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedIntegerColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_integer";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_integer"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedIntegerEqColumn

Defined in: eql/v3/columns.ts:560

Extends

Constructors

Constructor
new EncryptedIntegerEqColumn(columnName, definition): EncryptedIntegerEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_integer_eq" = 'public.eql_v3_integer_eq'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedIntegerEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_integer_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_integer_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedIntegerOrdOreColumn

Defined in: eql/v3/columns.ts:563

Extends

Constructors

Constructor
new EncryptedIntegerOrdOreColumn(columnName, definition): EncryptedIntegerOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_integer_ord_ore" = 'public.eql_v3_integer_ord_ore'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedIntegerOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_integer_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_integer_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedIntegerOrdColumn

Defined in: eql/v3/columns.ts:566

Extends

Constructors

Constructor
new EncryptedIntegerOrdColumn(columnName, definition): EncryptedIntegerOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_integer_ord" = 'public.eql_v3_integer_ord'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedIntegerOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_integer_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_integer_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedSmallintColumn

Defined in: eql/v3/columns.ts:571

Extends

Constructors

Constructor
new EncryptedSmallintColumn(columnName, definition): EncryptedSmallintColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_smallint" = 'public.eql_v3_smallint'

castAs

"number" = 'number'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedSmallintColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_smallint";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_smallint"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedSmallintEqColumn

Defined in: eql/v3/columns.ts:574

Extends

Constructors

Constructor
new EncryptedSmallintEqColumn(columnName, definition): EncryptedSmallintEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_smallint_eq" = 'public.eql_v3_smallint_eq'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedSmallintEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_smallint_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_smallint_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedSmallintOrdOreColumn

Defined in: eql/v3/columns.ts:577

Extends

Constructors

Constructor
new EncryptedSmallintOrdOreColumn(columnName, definition): EncryptedSmallintOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_smallint_ord_ore" = 'public.eql_v3_smallint_ord_ore'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedSmallintOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_smallint_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_smallint_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedSmallintOrdColumn

Defined in: eql/v3/columns.ts:580

Extends

Constructors

Constructor
new EncryptedSmallintOrdColumn(columnName, definition): EncryptedSmallintOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_smallint_ord" = 'public.eql_v3_smallint_ord'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedSmallintOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_smallint_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_smallint_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedBigintColumn

Defined in: eql/v3/columns.ts:586

Extends

Constructors

Constructor
new EncryptedBigintColumn(columnName, definition): EncryptedBigintColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_bigint" = 'public.eql_v3_bigint'

castAs

"bigint" = 'bigint'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedBigintColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_bigint";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_bigint"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedBigintEqColumn

Defined in: eql/v3/columns.ts:587

Extends

Constructors

Constructor
new EncryptedBigintEqColumn(columnName, definition): EncryptedBigintEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_bigint_eq" = 'public.eql_v3_bigint_eq'

castAs

"bigint" = 'bigint'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedBigintEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_bigint_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_bigint_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedBigintOrdOreColumn

Defined in: eql/v3/columns.ts:590

Extends

Constructors

Constructor
new EncryptedBigintOrdOreColumn(columnName, definition): EncryptedBigintOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_bigint_ord_ore" = 'public.eql_v3_bigint_ord_ore'

castAs

"bigint" = 'bigint'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedBigintOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_bigint_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_bigint_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedBigintOrdColumn

Defined in: eql/v3/columns.ts:593

Extends

Constructors

Constructor
new EncryptedBigintOrdColumn(columnName, definition): EncryptedBigintOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_bigint_ord" = 'public.eql_v3_bigint_ord'

castAs

"bigint" = 'bigint'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedBigintOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_bigint_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_bigint_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDateColumn

Defined in: eql/v3/columns.ts:598

Extends

Constructors

Constructor
new EncryptedDateColumn(columnName, definition): EncryptedDateColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_date" = 'public.eql_v3_date'

castAs

"date" = 'date'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedDateColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_date";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_date"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDateEqColumn

Defined in: eql/v3/columns.ts:599

Extends

Constructors

Constructor
new EncryptedDateEqColumn(columnName, definition): EncryptedDateEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_date_eq" = 'public.eql_v3_date_eq'

castAs

"date" = 'date'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedDateEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_date_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_date_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDateOrdOreColumn

Defined in: eql/v3/columns.ts:600

Extends

Constructors

Constructor
new EncryptedDateOrdOreColumn(columnName, definition): EncryptedDateOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_date_ord_ore" = 'public.eql_v3_date_ord_ore'

castAs

"date" = 'date'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedDateOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_date_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_date_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDateOrdColumn

Defined in: eql/v3/columns.ts:603

Extends

Constructors

Constructor
new EncryptedDateOrdColumn(columnName, definition): EncryptedDateOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_date_ord" = 'public.eql_v3_date_ord'

castAs

"date" = 'date'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedDateOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_date_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_date_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTimestampColumn

Defined in: eql/v3/columns.ts:608

Extends

Constructors

Constructor
new EncryptedTimestampColumn(columnName, definition): EncryptedTimestampColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_timestamp" = 'public.eql_v3_timestamp'

castAs

"timestamp" = 'timestamp'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedTimestampColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_timestamp";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_timestamp"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTimestampEqColumn

Defined in: eql/v3/columns.ts:611

Extends

Constructors

Constructor
new EncryptedTimestampEqColumn(columnName, definition): EncryptedTimestampEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_timestamp_eq" = 'public.eql_v3_timestamp_eq'

castAs

"timestamp" = 'timestamp'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedTimestampEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_timestamp_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_timestamp_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTimestampOrdOreColumn

Defined in: eql/v3/columns.ts:614

Extends

Constructors

Constructor
new EncryptedTimestampOrdOreColumn(columnName, definition): EncryptedTimestampOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_timestamp_ord_ore" = 'public.eql_v3_timestamp_ord_ore'

castAs

"timestamp" = 'timestamp'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedTimestampOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_timestamp_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_timestamp_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTimestampOrdColumn

Defined in: eql/v3/columns.ts:617

Extends

Constructors

Constructor
new EncryptedTimestampOrdColumn(columnName, definition): EncryptedTimestampOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_timestamp_ord" = 'public.eql_v3_timestamp_ord'

castAs

"timestamp" = 'timestamp'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedTimestampOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_timestamp_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_timestamp_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedNumericColumn

Defined in: eql/v3/columns.ts:622

Extends

Constructors

Constructor
new EncryptedNumericColumn(columnName, definition): EncryptedNumericColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_numeric" = 'public.eql_v3_numeric'

castAs

"number" = 'number'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedNumericColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_numeric";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_numeric"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedNumericEqColumn

Defined in: eql/v3/columns.ts:623

Extends

Constructors

Constructor
new EncryptedNumericEqColumn(columnName, definition): EncryptedNumericEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_numeric_eq" = 'public.eql_v3_numeric_eq'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedNumericEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_numeric_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_numeric_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedNumericOrdOreColumn

Defined in: eql/v3/columns.ts:626

Extends

Constructors

Constructor
new EncryptedNumericOrdOreColumn(columnName, definition): EncryptedNumericOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_numeric_ord_ore" = 'public.eql_v3_numeric_ord_ore'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedNumericOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_numeric_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_numeric_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedNumericOrdColumn

Defined in: eql/v3/columns.ts:629

Extends

Constructors

Constructor
new EncryptedNumericOrdColumn(columnName, definition): EncryptedNumericOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_numeric_ord" = 'public.eql_v3_numeric_ord'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedNumericOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_numeric_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_numeric_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTextColumn

Defined in: eql/v3/columns.ts:634

Extends

Constructors

Constructor
new EncryptedTextColumn(columnName, definition): EncryptedTextColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_text" = 'public.eql_v3_text'

castAs

"string" = 'string'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedTextColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_text";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_text"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTextEqColumn

Defined in: eql/v3/columns.ts:635

Extends

Constructors

Constructor
new EncryptedTextEqColumn(columnName, definition): EncryptedTextEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_text_eq" = 'public.eql_v3_text_eq'

castAs

"string" = 'string'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedTextEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_text_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_text_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTextMatchColumn

Defined in: eql/v3/columns.ts:636

Extends

Constructors

Constructor
new EncryptedTextMatchColumn(columnName, definition): EncryptedTextMatchColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_text_match" = 'public.eql_v3_text_match'

castAs

"string" = 'string'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: true; } = MATCH_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

true = true

Returns

EncryptedTextMatchColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_text_match";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_text_match"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: true;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: true;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: true = true;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTextOrdOreColumn

Defined in: eql/v3/columns.ts:639

Extends

Constructors

Constructor
new EncryptedTextOrdOreColumn(columnName, definition): EncryptedTextOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_text_ord_ore" = 'public.eql_v3_text_ord_ore'

castAs

"string" = 'string'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedTextOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_text_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_text_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTextOrdColumn

Defined in: eql/v3/columns.ts:642

Extends

Constructors

Constructor
new EncryptedTextOrdColumn(columnName, definition): EncryptedTextOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_text_ord" = 'public.eql_v3_text_ord'

castAs

"string" = 'string'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedTextOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_text_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_text_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedBooleanColumn

Defined in: eql/v3/columns.ts:647

Extends

Constructors

Constructor
new EncryptedBooleanColumn(columnName, definition): EncryptedBooleanColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_boolean" = 'public.eql_v3_boolean'

castAs

"boolean" = 'boolean'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedBooleanColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_boolean";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_boolean"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedRealColumn

Defined in: eql/v3/columns.ts:650

Extends

Constructors

Constructor
new EncryptedRealColumn(columnName, definition): EncryptedRealColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_real" = 'public.eql_v3_real'

castAs

"number" = 'number'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedRealColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_real";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_real"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedRealEqColumn

Defined in: eql/v3/columns.ts:651

Extends

Constructors

Constructor
new EncryptedRealEqColumn(columnName, definition): EncryptedRealEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_real_eq" = 'public.eql_v3_real_eq'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedRealEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_real_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_real_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedRealOrdOreColumn

Defined in: eql/v3/columns.ts:652

Extends

Constructors

Constructor
new EncryptedRealOrdOreColumn(columnName, definition): EncryptedRealOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_real_ord_ore" = 'public.eql_v3_real_ord_ore'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedRealOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_real_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_real_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedRealOrdColumn

Defined in: eql/v3/columns.ts:655

Extends

Constructors

Constructor
new EncryptedRealOrdColumn(columnName, definition): EncryptedRealOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_real_ord" = 'public.eql_v3_real_ord'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedRealOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_real_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_real_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDoubleColumn

Defined in: eql/v3/columns.ts:660

Extends

Constructors

Constructor
new EncryptedDoubleColumn(columnName, definition): EncryptedDoubleColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_double" = 'public.eql_v3_double'

castAs

"number" = 'number'

capabilities

{ equality: false; orderAndRange: false; freeTextSearch: false; } = STORAGE_ONLY

capabilities.equality

false = false

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedDoubleColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_double";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_double"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): false;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

false

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDoubleEqColumn

Defined in: eql/v3/columns.ts:661

Extends

Constructors

Constructor
new EncryptedDoubleEqColumn(columnName, definition): EncryptedDoubleEqColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_double_eq" = 'public.eql_v3_double_eq'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: false; freeTextSearch: false; } = EQUALITY_ONLY

capabilities.equality

true = true

capabilities.orderAndRange

false = false

capabilities.freeTextSearch

false = false

Returns

EncryptedDoubleEqColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_double_eq";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_double_eq"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: false;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDoubleOrdOreColumn

Defined in: eql/v3/columns.ts:664

Extends

Constructors

Constructor
new EncryptedDoubleOrdOreColumn(columnName, definition): EncryptedDoubleOrdOreColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_double_ord_ore" = 'public.eql_v3_double_ord_ore'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedDoubleOrdOreColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_double_ord_ore";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_double_ord_ore"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedDoubleOrdColumn

Defined in: eql/v3/columns.ts:667

Extends

Constructors

Constructor
new EncryptedDoubleOrdColumn(columnName, definition): EncryptedDoubleOrdColumn;

Defined in: eql/v3/columns.ts:474

Parameters
columnName

string

definition
eqlType

"public.eql_v3_double_ord" = 'public.eql_v3_double_ord'

castAs

"number" = 'number'

capabilities

{ equality: true; orderAndRange: true; freeTextSearch: false; } = ORDER_AND_RANGE

capabilities.equality

true = true

capabilities.orderAndRange

true = true

capabilities.freeTextSearch

false = false

Returns

EncryptedDoubleOrdColumn

Inherited from

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_double_ord";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_double_ord"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: true;
  orderAndRange: true;
  freeTextSearch: false;
}
equality
readonly equality: true = true;
orderAndRange
readonly orderAndRange: true = true;
freeTextSearch
readonly freeTextSearch: false = false;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedJsonColumn

Defined in: eql/v3/columns.ts:690

Builder for a public.eql_v3_json_search column — an encrypted JSONB document (a JsonDocument: object, array, or null). It round-trips through encrypt/decrypt, and containment queries use the encrypted-JSONB index emitted by build(). (The stored payload is protect-ffi's SteVecDocument, and the config index kind is ste_vec — both protect-ffi names.)

Extends

Constructors

Constructor
new EncryptedJsonColumn(columnName): EncryptedJsonColumn;

Defined in: eql/v3/columns.ts:691

Parameters
columnName

string

Returns

EncryptedJsonColumn

Overrides

EncryptedV3Column.constructor

Methods

getName()
getName(): string;

Defined in: eql/v3/columns.ts:479

Returns

string

Inherited from

EncryptedV3Column.getName

getEqlType()
getEqlType(): "public.eql_v3_json_search";

Defined in: eql/v3/columns.ts:484

The concrete EQL v3 domain name. Metadata only; not emitted by build().

Returns

"public.eql_v3_json_search"

Inherited from

EncryptedV3Column.getEqlType

getQueryCapabilities()
getQueryCapabilities(): {
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
  searchableJson: true;
};

Defined in: eql/v3/columns.ts:489

The semantic query capabilities this domain exposes. Metadata only.

Returns
{
  equality: false;
  orderAndRange: false;
  freeTextSearch: false;
  searchableJson: true;
}
equality
readonly equality: false = false;
orderAndRange
readonly orderAndRange: false = false;
freeTextSearch
readonly freeTextSearch: false = false;
searchableJson
readonly searchableJson: true = true;
Inherited from

EncryptedV3Column.getQueryCapabilities

isQueryable()
isQueryable(): true;

Defined in: eql/v3/columns.ts:494

true when this domain can produce at least one kind of query term.

Returns

true

Inherited from

EncryptedV3Column.isQueryable

build()
build(): {
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
};

Defined in: eql/v3/columns.ts:501

Emit the encrypt-config column: cast_as plus capability-derived indexes.

Returns
{
  cast_as:   | "string"
     | "number"
     | "bigint"
     | "boolean"
     | "date"
     | "text"
     | "timestamp"
     | "json";
  indexes: {
     ore?: {
     };
     ope?: {
     };
     unique?: {
        token_filters?: {
           kind: "downcase";
        }[];
     };
     match?: {
        tokenizer?:   | {
           kind: "standard";
         }
           | {
           kind: "ngram";
           token_length: number;
         };
        token_filters?: {
           kind: "downcase";
        }[];
        k?: number;
        m?: number;
        include_original?: boolean;
     };
     ste_vec?: {
        prefix: string;
        array_index_mode?:   | "all"
           | "none"
           | {
           item?: boolean;
           wildcard?: boolean;
           position?: boolean;
         };
        mode?: "standard" | "compat";
     };
  };
}
cast_as
cast_as: 
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "date"
  | "text"
  | "timestamp"
  | "json" = castAsEnum;
indexes
indexes: {
  ore?: {
  };
  ope?: {
  };
  unique?: {
     token_filters?: {
        kind: "downcase";
     }[];
  };
  match?: {
     tokenizer?:   | {
        kind: "standard";
      }
        | {
        kind: "ngram";
        token_length: number;
      };
     token_filters?: {
        kind: "downcase";
     }[];
     k?: number;
     m?: number;
     include_original?: boolean;
  };
  ste_vec?: {
     prefix: string;
     array_index_mode?:   | "all"
        | "none"
        | {
        item?: boolean;
        wildcard?: boolean;
        position?: boolean;
      };
     mode?: "standard" | "compat";
  };
} = indexesSchema;
indexes.ore?
optional ore: {
};
indexes.ope?
optional ope: {
};
indexes.unique?
optional unique: {
  token_filters?: {
     kind: "downcase";
  }[];
};
indexes.unique.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match?
optional match: {
  tokenizer?:   | {
     kind: "standard";
   }
     | {
     kind: "ngram";
     token_length: number;
   };
  token_filters?: {
     kind: "downcase";
  }[];
  k?: number;
  m?: number;
  include_original?: boolean;
};
indexes.match.tokenizer?
optional tokenizer: 
  | {
  kind: "standard";
}
  | {
  kind: "ngram";
  token_length: number;
} = tokenizerSchema;
indexes.match.token_filters?
optional token_filters: {
  kind: "downcase";
}[];
indexes.match.k?
optional k: number;
indexes.match.m?
optional m: number;
indexes.match.include_original?
optional include_original: boolean;
indexes.ste_vec?
optional ste_vec: {
  prefix: string;
  array_index_mode?:   | "all"
     | "none"
     | {
     item?: boolean;
     wildcard?: boolean;
     position?: boolean;
   };
  mode?: "standard" | "compat";
};
indexes.ste_vec.prefix
prefix: string;
indexes.ste_vec.array_index_mode?
optional array_index_mode: 
  | "all"
  | "none"
  | {
  item?: boolean;
  wildcard?: boolean;
  position?: boolean;
};
indexes.ste_vec.mode?
optional mode: "standard" | "compat";
Inherited from

EncryptedV3Column.build


EncryptedTable

Defined in: eql/v3/table.ts:18

A v3 encrypted table. Mirrors the v2 EncryptedTable but only accepts v3 column builders. Emits the same { tableName, columns } definition shape.

Type Parameters

T

T extends EncryptedV3TableColumn

Constructors

Constructor
new EncryptedTable<T>(tableName, columnBuilders): EncryptedTable<T>;

Defined in: eql/v3/table.ts:22

Parameters
tableName

string

columnBuilders

T

Returns

EncryptedTable<T>

Properties

tableName
readonly tableName: string;

Defined in: eql/v3/table.ts:23

columnBuilders
readonly columnBuilders: T;

Defined in: eql/v3/table.ts:24

Methods

build()
build(): TableDefinition;

Defined in: eql/v3/table.ts:27

Returns

TableDefinition

buildColumnKeyMap()
buildColumnKeyMap(): Record&lt;string, string&gt;;

Defined in: eql/v3/table.ts:77

Map each column's JS property name to its DB column name (getName()). The model path matches user models by property name but must address the encrypt config and FFI by DB name — build() keys columns by DB name, so the two only agree when property == name. This recovers the mapping that build() discards.

NULL PROTOTYPE — load-bearing. Callers index this map by a column name that ultimately comes from the database (addJsonbCastsV3, filterColumnName, the mutation transform). On a plain object literal, a column named constructor / toString / valueOf / __proto__ resolves to an inherited Object.prototype member, which is truthy — so a plaintext column with such a name would be mistaken for a mapped encrypted column and its Object.prototype value interpolated into the emitted select string. encryptedTable() rejects such names as JS properties, but nothing constrains the DB column names a table may contain.

Returns

Record<string, string>

Type Aliases

QueryCapabilities

type QueryCapabilities = Readonly&lt;{
  equality: boolean;
  orderAndRange: boolean;
  freeTextSearch: boolean;
  searchableJson?: boolean;
}&gt;;

Defined in: eql/v3/columns.ts:17

The query capabilities a v3 concrete domain exposes. These are SDK-facing semantic flags describing what kinds of query terms a column can produce — NOT the raw EQL index keys. They are metadata only and never emitted by build().

  • equality: exact-match lookups (EQL hm, or comparison via ob).
  • orderAndRange: comparison / range lookups (EQL op, or ob on _ord_ore domains).
  • freeTextSearch: tokenised substring match (EQL bf).
  • searchableJson: encrypted-JSONB containment / selector lookups (EQL ste_vec). Optional and mutually exclusive with the scalar flags — a public.eql_v3_json_search document is queried by structure, not by scalar term.

AnyEncryptedV3Column

type AnyEncryptedV3Column = 
  | EncryptedIntegerColumn
  | EncryptedIntegerEqColumn
  | EncryptedIntegerOrdOreColumn
  | EncryptedIntegerOrdColumn
  | EncryptedSmallintColumn
  | EncryptedSmallintEqColumn
  | EncryptedSmallintOrdOreColumn
  | EncryptedSmallintOrdColumn
  | EncryptedBigintColumn
  | EncryptedBigintEqColumn
  | EncryptedBigintOrdOreColumn
  | EncryptedBigintOrdColumn
  | EncryptedDateColumn
  | EncryptedDateEqColumn
  | EncryptedDateOrdOreColumn
  | EncryptedDateOrdColumn
  | EncryptedTimestampColumn
  | EncryptedTimestampEqColumn
  | EncryptedTimestampOrdOreColumn
  | EncryptedTimestampOrdColumn
  | EncryptedNumericColumn
  | EncryptedNumericEqColumn
  | EncryptedNumericOrdOreColumn
  | EncryptedNumericOrdColumn
  | EncryptedTextColumn
  | EncryptedTextEqColumn
  | EncryptedTextMatchColumn
  | EncryptedTextOrdOreColumn
  | EncryptedTextOrdColumn
  | EncryptedTextSearchColumn
  | EncryptedBooleanColumn
  | EncryptedRealColumn
  | EncryptedRealEqColumn
  | EncryptedRealOrdOreColumn
  | EncryptedRealOrdColumn
  | EncryptedDoubleColumn
  | EncryptedDoubleEqColumn
  | EncryptedDoubleOrdOreColumn
  | EncryptedDoubleOrdColumn
  | EncryptedJsonColumn;

Defined in: eql/v3/columns.ts:700

Union of every v3 concrete column type. Used as the value type for v3 table columns so a table may mix any generated domains.


EncryptedV3TableColumn

type EncryptedV3TableColumn = {
[key: string]: AnyEncryptedV3Column;
};

Defined in: eql/v3/columns.ts:755

Shape of v3 table columns: every value is a v3 concrete column builder. (Nested fields are deferred to later increments.)

Index Signature

[key: string]: AnyEncryptedV3Column

JsonValue

type JsonValue = 
  | string
  | number
  | boolean
  | null
  | JsonValue[]
  | {
[key: string]: JsonValue;
};

Defined in: eql/v3/columns.ts:760

A JSON value at any depth. Used for the values NESTED inside a document.


JsonDocument

type JsonDocument = 
  | null
  | JsonValue[]
  | {
[key: string]: JsonValue;
};

Defined in: eql/v3/columns.ts:776

The plaintext a public.eql_v3_json_search column encrypts and reconstructs: a JSON DOCUMENT — an object, an array, or null. NOT a bare top-level scalar: protect-ffi's json cast rejects a top-level string/number/boolean ("Cannot convert … to Json"), because a scalar belongs in a scalar domain (types.TextEq, types.IntegerEq, …). Nested scalars are ordinary JsonValues and are fully supported.


PlaintextForColumn

type PlaintextForColumn&lt;C&gt; = C extends EncryptedV3Column&lt;infer D&gt; ? PlaintextFromKind&lt;D["castAs"]&gt; : never;

Defined in: eql/v3/columns.ts:800

The plaintext type for a single v3 column, read from the literal domain definition carried on the base class's private field. This is stable across empty subclasses that share the same base generic — a subclass-name conditional would collapse because those subclasses are structurally assignable to one another.

Type Parameters

C

C


QueryTypesForColumn

type QueryTypesForColumn&lt;C&gt; = C extends EncryptedV3Column&lt;infer D&gt; ? 
  | D["capabilities"]["equality"] extends true ? "equality" : never
  | D["capabilities"]["orderAndRange"] extends true ? "orderAndRange" : never
  | D["capabilities"]["freeTextSearch"] extends true ? "freeTextSearch" : never
  | D["capabilities"]["searchableJson"] extends true ? "searchableJson" : never : never;

Defined in: eql/v3/columns.ts:809

The user-facing queryType names a v3 column supports, derived 1:1 from its capability flags. Resolves to never for a storage-only column (all flags false) and for any non-v3 value. The names mirror the QueryCapabilities keys, each of which is also a import('@/types').QueryTypeName member.

Type Parameters

C

C


EqlTypeForColumn

type EqlTypeForColumn&lt;C&gt; = C extends EncryptedV3Column&lt;infer D&gt; ? D["eqlType"] : never;

Defined in: eql/v3/columns.ts:836

The concrete EQL v3 type string for a single column, read from the literal domain definition carried on the base class's private field (mirrors PlaintextForColumn). Distributes over a union of columns, so EqlTypeForColumn&lt;AnyEncryptedV3Column&gt; yields the union of every domain's eqlType — the canonical, source-of-truth key set for a type-driven test matrix keyed by domain.

Type Parameters

C

C


InferPlaintext

type InferPlaintext&lt;T&gt; = T extends EncryptedTable&lt;infer C&gt; ? { [K in keyof C]: PlaintextForColumn&lt;C[K]&gt; } : never;

Defined in: eql/v3/table.ts:171

Infer the plaintext (decrypted) shape from a v3 table schema. Each column maps to the TypeScript type of its domain's castAs kind.

Type Parameters

T

T extends EncryptedTable<EncryptedV3TableColumn>


InferEncrypted

type InferEncrypted&lt;T&gt; = T extends EncryptedTable&lt;infer C&gt; ? { [K in keyof C]: Encrypted } : never;

Defined in: eql/v3/table.ts:180

Infer the encrypted shape from a v3 table schema. See InferPlaintext for why no key-remap filter is needed in the flat single-type model.

Type Parameters

T

T extends EncryptedTable<EncryptedV3TableColumn>


AnyV3Table

type AnyV3Table = EncryptedTable&lt;EncryptedV3TableColumn&gt;;

Defined in: eql/v3/table.ts:188

Any v3 table, regardless of its column map.


ColumnsOf

type ColumnsOf&lt;T&