@commercelayer/sdk-utils/lib/helpers/filter/base.d.ts

Commerce Layer Javascript SDK Utils library

import { QueryFilter } from '@commercelayer/sdk';
import { NonEmptyString } from '../../types.js';

type NoValOperator = () => QueryFilter;
type SingleValOperator = <T extends string>(val: NonEmptyString<T>) => QueryFilter;
type MultipleValOperator = <T extends string>(...val: Array<NonEmptyString<T>>) => QueryFilter;
declare class Filter {
    #private;
    clear(): this;
    add(val: string): this;
    get(): string[];
}
declare class FilterObject {
    protected readonly filterValues: Filter;
    constructor(filterVals?: Filter);
    protected addValue(val: string): Filter;
}
interface FilterMaster extends FilterObject {
}
declare class FilterOperator<M extends FilterMaster> extends FilterObject {
    #private;
    constructor(master: M, filter?: Filter);
    private addOperator;
    private keyval;
    private build;
    eq: SingleValOperator;
    eq_or_null: SingleValOperator;
    not_eq: SingleValOperator;
    not_eq_or_null: SingleValOperator;
    matches: SingleValOperator;
    does_not_match: SingleValOperator;
    matches_any: MultipleValOperator;
    matches_all: MultipleValOperator;
    does_not_match_any: MultipleValOperator;
    does_not_match_all: MultipleValOperator;
    lt: SingleValOperator;
    lteq: SingleValOperator;
    gt: SingleValOperator;
    gteq: SingleValOperator;
    present: NoValOperator;
    blank: NoValOperator;
    null: NoValOperator;
    not_null: NoValOperator;
    in: MultipleValOperator;
    in_or_null: SingleValOperator;
    not_in: MultipleValOperator;
    not_in_or_null: MultipleValOperator;
    lt_any: MultipleValOperator;
    lteq_any: MultipleValOperator;
    gt_any: MultipleValOperator;
    gteq_any: MultipleValOperator;
    lt_all: MultipleValOperator;
    lteq_all: MultipleValOperator;
    gt_all: MultipleValOperator;
    gteq_all: MultipleValOperator;
    not_eq_all: MultipleValOperator;
    start: SingleValOperator;
    not_start: SingleValOperator;
    start_any: MultipleValOperator;
    not_start_any: MultipleValOperator;
    not_start_all: MultipleValOperator;
    end: SingleValOperator;
    not_end: SingleValOperator;
    end_any: MultipleValOperator;
    end_all: MultipleValOperator;
    not_end_any: MultipleValOperator;
    not_end_all: MultipleValOperator;
    cont: SingleValOperator;
    not_cont: SingleValOperator;
    cont_any: MultipleValOperator;
    cont_all: MultipleValOperator;
    not_cont_all: MultipleValOperator;
    jcont: SingleValOperator;
    true: NoValOperator;
    false: NoValOperator;
    get or(): M;
}
declare abstract class FilterOperand<M extends FilterMaster> extends FilterObject {
    protected readonly master: M;
    protected readonly operator: FilterOperator<M>;
    constructor(master?: M, operator?: FilterOperator<M>, filter?: Filter);
    protected addField(val: string): typeof this.operator;
    protected addRelationship(val: string): Filter;
}
declare class ResourceFilterFields<M extends FilterMaster> extends FilterOperand<M> {
    get id(): FilterOperator<M>;
    get created_at(): FilterOperator<M>;
    get updated_at(): FilterOperator<M>;
    get reference(): FilterOperator<M>;
    get reference_origin(): FilterOperator<M>;
    get metadata(): FilterOperator<M>;
}
type ResourceFilter = ResourceFilterFields<ResourceFilter>;

export { type FilterMaster, FilterOperand, FilterOperator, type ResourceFilter, ResourceFilterFields };