@archbase/core 3.0.0

package/dist/locales/index.d.ts

@@ -0,0 +1 @@
+export * from './config';

package/dist/rsql/ast/ComparisonOperator.d.ts

@@ -0,0 +1,24 @@
+declare const EQ: "==";
+declare const NEQ: "!=";
+declare const LE: "<=";
+declare const GE: ">=";
+declare const LT: "<";
+declare const GT: ">";
+declare const IN: "=in=";
+declare const OUT: "=out=";
+declare const BT: "=bt=";
+declare const NB: "=nb=";
+declare const LE_VERBOSE: "=le=";
+declare const GE_VERBOSE: "=ge=";
+declare const LT_VERBOSE: "=lt=";
+declare const GT_VERBOSE: "=gt=";
+type CustomComparisonOperator = string;
+declare const CanonicalComparisonOperators: ("!=" | ">" | "<" | ">=" | "<=" | "==" | "=in=" | "=out=" | "=bt=" | "=nb=")[];
+type CanonicalComparisonOperator = (typeof CanonicalComparisonOperators)[number];
+declare const VerboseComparisonOperators: ("=le=" | "=ge=" | "=lt=" | "=gt=")[];
+type VerboseComparisonOperator = (typeof VerboseComparisonOperators)[number];
+declare const ComparisonOperators: ("!=" | ">" | "<" | ">=" | "<=" | "==" | "=in=" | "=out=" | "=bt=" | "=nb=" | "=le=" | "=ge=" | "=lt=" | "=gt=")[];
+type ComparisonOperator = (typeof ComparisonOperators)[number] | CustomComparisonOperator;
+declare function isComparisonOperator(candidate: string, operator?: ComparisonOperator): candidate is ComparisonOperator;
+export { EQ, NEQ, LE, GE, LT, GT, IN, OUT, BT, NB, LE_VERBOSE, GE_VERBOSE, LT_VERBOSE, GT_VERBOSE, ComparisonOperators, CanonicalComparisonOperators, VerboseComparisonOperators, isComparisonOperator, };
+export type { ComparisonOperator, CanonicalComparisonOperator, VerboseComparisonOperator };

package/dist/rsql/ast/LogicOperator.d.ts

@@ -0,0 +1,13 @@
+declare const AND: ";";
+declare const OR: ",";
+declare const AND_VERBOSE: "and";
+declare const OR_VERBOSE: "or";
+declare const CanonicalLogicOperators: (";" | ",")[];
+type CanonicalLogicOperator = (typeof CanonicalLogicOperators)[number];
+declare const VerboseLogicOperators: ("and" | "or")[];
+type VerboseLogicOperator = (typeof VerboseLogicOperators)[number];
+declare const LogicOperators: (";" | "," | "and" | "or")[];
+type LogicOperator = (typeof LogicOperators)[number];
+declare function isLogicOperator(candidate: string, operator?: LogicOperator): candidate is LogicOperator;
+export { AND, OR, AND_VERBOSE, OR_VERBOSE, CanonicalLogicOperators, VerboseLogicOperators, LogicOperators, isLogicOperator };
+export type { CanonicalLogicOperator, VerboseLogicOperator, LogicOperator };

package/dist/rsql/ast/Node.d.ts

@@ -0,0 +1,41 @@
+import { ComparisonOperator } from './ComparisonOperator';
+import { LogicOperator } from './LogicOperator';
+declare const NodeType: {
+    readonly SELECTOR: "SELECTOR";
+    readonly VALUE: "VALUE";
+    readonly COMPARISON: "COMPARISON";
+    readonly LOGIC: "LOGIC";
+};
+interface Node<TType = string> {
+    readonly type: TType;
+}
+interface SelectorNode extends Node<typeof NodeType.SELECTOR> {
+    readonly selector: string;
+}
+interface ValueNode extends Node<typeof NodeType.VALUE> {
+    readonly value: string | string[];
+}
+interface BinaryNode<TType extends string = string, TLeft extends Node = Node, TOperator extends string = string, TRight extends Node = Node> extends Node<TType> {
+    readonly left: TLeft;
+    readonly operator: TOperator;
+    readonly right: TRight;
+}
+type ComparisonNode = BinaryNode<typeof NodeType.COMPARISON, SelectorNode, ComparisonOperator, ValueNode>;
+type LogicNode = BinaryNode<typeof NodeType.LOGIC, ExpressionNode, LogicOperator, ExpressionNode>;
+type ExpressionNode = ComparisonNode | LogicNode;
+declare function isNode(candidate: unknown): candidate is Node;
+declare function isSelectorNode(candidate: unknown): candidate is SelectorNode;
+declare function isValueNode(candidate: unknown): candidate is ValueNode;
+declare function isComparisonNode(candidate: unknown, operator?: ComparisonOperator): candidate is ComparisonNode;
+declare function isLogicNode(candidate: unknown, operator?: LogicOperator): candidate is LogicNode;
+declare function isExpressionNode(candidate: unknown): candidate is ExpressionNode;
+declare function getSelector(comparison: ComparisonNode): string;
+declare function getValue(comparison: ComparisonNode): string | string[];
+declare function getSingleValue(comparison: ComparisonNode): string;
+declare function getMultiValue(comparison: ComparisonNode): string[];
+declare function createSelectorNode(selector: string, skipChecks?: boolean): SelectorNode;
+declare function createValueNode(value: string | string[], skipChecks?: boolean): ValueNode;
+declare function createComparisonNode(selector: SelectorNode, operator: ComparisonOperator, value: ValueNode, skipChecks?: boolean): ComparisonNode;
+declare function createLogicNode(left: ExpressionNode, operator: LogicOperator, right: ExpressionNode, skipChecks?: boolean): LogicNode;
+export { createSelectorNode, createValueNode, createComparisonNode, createLogicNode, isNode, isSelectorNode, isValueNode, isComparisonNode, isLogicNode, isExpressionNode, getSelector, getValue, getSingleValue, getMultiValue, };
+export type { Node, SelectorNode, ValueNode, BinaryNode, ComparisonNode, LogicNode, ExpressionNode };

package/dist/rsql/ast/ReservedChars.d.ts

@@ -0,0 +1,4 @@
+declare const ReservedChars: readonly ["\"", "'", "(", ")", ";", ",", "=", "!", "~", "<", ">", " ", "\n", "\t", "\r"];
+type ReservedChar = (typeof ReservedChars)[number];
+export { ReservedChars };
+export type { ReservedChar };

package/dist/rsql/ast/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ComparisonOperator';
+export * from './LogicOperator';
+export * from './ReservedChars';
+export * from './Node';

package/dist/rsql/builder/index.d.ts

@@ -0,0 +1,20 @@
+import { ComparisonOperator, LogicOperator, ComparisonNode, ExpressionNode } from '../ast';
+interface Builder {
+    comparison(selector: string, operator: ComparisonOperator, value: string | number | (string | number)[]): ComparisonNode;
+    eq(selector: string, value: string | number): ComparisonNode;
+    bt(selector: string, value1: string | number, value2: string | number): ComparisonNode;
+    nb(selector: string, value1: string | number, value2: string | number): ComparisonNode;
+    neq(selector: string, value: string | number): ComparisonNode;
+    le(selector: string, value: string | number): ComparisonNode;
+    lt(selector: string, value: string | number): ComparisonNode;
+    ge(selector: string, value: string | number): ComparisonNode;
+    gt(selector: string, value: string | number): ComparisonNode;
+    in(selector: string, values: (string | number)[]): ComparisonNode;
+    out(selector: string, values: (string | number)[]): ComparisonNode;
+    logic(expressions: ExpressionNode[], operator: LogicOperator): ExpressionNode;
+    and(...expressions: ExpressionNode[]): ExpressionNode;
+    or(...expressions: ExpressionNode[]): ExpressionNode;
+}
+declare const builder: Builder;
+export { builder };
+export type { Builder };

package/dist/rsql/emitter/index.d.ts

@@ -0,0 +1,19 @@
+import { ExpressionNode } from '../ast';
+type Quote = '"' | "'";
+interface EmitOptions {
+    /**
+     * The preferred quote character to use when `emit` encounters a comparison value that needs to be escaped by wrapping
+     * in quotes. Either `"` (the ASCII double quote character) or `'` (the ASCII single quote character). Defaults to `"`
+     * (the ASCII double quote character).
+     */
+    preferredQuote?: Quote;
+    /**
+     * If `true`, `emit` will override the `preferredQuote` setting on a comparison value-by-comparison value basis if
+     * doing so would shorten the emitted RSQL. If `false`, `emit` will use the `preferredQuote` as the quote character
+     * for all comparison values encountered. Defaults to `true`.
+     */
+    optimizeQuotes?: boolean;
+}
+declare function emit(expression: ExpressionNode, options?: EmitOptions): string;
+export { emit };
+export type { EmitOptions, Quote };

package/dist/rsql/index.d.ts

@@ -0,0 +1,7 @@
+export interface RSQLQuery {
+    field: string;
+    operator: string;
+    value: string | number | boolean;
+}
+export declare function parseRSQL(query: string): RSQLQuery[];
+export declare function buildRSQL(queries: RSQLQuery[]): string;

package/dist/rsql/parser/Error.d.ts

@@ -0,0 +1,7 @@
+import { AnyToken } from './lexer/Token';
+declare function createErrorForUnexpectedCharacter(position: number, source: string): SyntaxError;
+declare function createErrorForUnclosedQuote(position: number, source: string): SyntaxError;
+declare function createErrorForUnexpectedToken(token: AnyToken, source: string): SyntaxError;
+declare function createErrorForUnclosedParenthesis(_token: AnyToken, source: string, parentPosition: number): SyntaxError;
+declare function createErrorForEmptyInput(_token: AnyToken, source: string): SyntaxError;
+export { createErrorForUnexpectedCharacter, createErrorForUnclosedQuote, createErrorForUnexpectedToken, createErrorForUnclosedParenthesis, createErrorForEmptyInput, };

package/dist/rsql/parser/ParserContext.d.ts

@@ -0,0 +1,15 @@
+import { Node } from '../ast';
+import { AnyToken } from './lexer/Token';
+interface ParserContext {
+    position: number;
+    readonly tokens: AnyToken[];
+    readonly stack: (AnyToken | Node)[];
+    readonly state: number[];
+    readonly parent: ParserContext | null;
+}
+declare function getParserContextState(context: ParserContext): number;
+declare function getParserContextToken(context: ParserContext): AnyToken;
+declare function getParserContextHead(context: ParserContext): AnyToken | Node;
+declare function createParserContext(tokens: AnyToken[]): ParserContext;
+export default ParserContext;
+export { getParserContextState, getParserContextToken, getParserContextHead, createParserContext };

package/dist/rsql/parser/ParserOperation.d.ts

@@ -0,0 +1,43 @@
+declare const OperationType: {
+    readonly SHIFT: 0;
+    readonly PUSH: 1;
+    readonly REDUCE: 2;
+    readonly POP: 3;
+    readonly GOTO: 4;
+    readonly ACCEPT: 5;
+};
+interface ShiftOperation {
+    type: typeof OperationType.SHIFT;
+    state: number;
+}
+interface PushOperation {
+    type: typeof OperationType.PUSH;
+    state: number;
+}
+interface ReduceOperation {
+    type: typeof OperationType.REDUCE;
+    production: number;
+}
+interface PopOperation {
+    type: typeof OperationType.POP;
+    production: number;
+}
+interface GoToOperation {
+    type: typeof OperationType.GOTO;
+    state: number;
+}
+interface AcceptOperation {
+    type: typeof OperationType.ACCEPT;
+}
+type NoOperation = undefined;
+type TokenOperation = ShiftOperation | ReduceOperation | PushOperation | PopOperation | AcceptOperation | NoOperation;
+type NodeOperation = GoToOperation | NoOperation;
+declare function shift(state: number): ShiftOperation;
+declare function reduce(production: number): ReduceOperation;
+declare function push(state: number): PushOperation;
+declare function pop(production: number): PopOperation;
+declare function goto(state: number): GoToOperation;
+declare function accept(): AcceptOperation;
+declare const noop: NoOperation;
+export { OperationType, shift, reduce, push, pop, accept, goto, noop };
+export type { ShiftOperation, ReduceOperation, PushOperation, PopOperation, AcceptOperation, GoToOperation, NoOperation, TokenOperation, NodeOperation, };

package/dist/rsql/parser/ParserProduction.d.ts

@@ -0,0 +1,14 @@
+import { Node } from '../ast';
+import { AnyToken } from './lexer/Token';
+type ParserProduction = (stack: (AnyToken | Node)[]) => {
+    consumed: number;
+    produced: Node;
+};
+declare const comparisonExpressionProduction: ParserProduction;
+declare const logicalExpressionProduction: ParserProduction;
+declare const groupExpressionProduction: ParserProduction;
+declare const selectorProduction: ParserProduction;
+declare const singleValueProduction: ParserProduction;
+declare const multiValueProduction: ParserProduction;
+export { selectorProduction, singleValueProduction, multiValueProduction, comparisonExpressionProduction, logicalExpressionProduction, groupExpressionProduction, };
+export type { ParserProduction };

package/dist/rsql/parser/index.d.ts

@@ -0,0 +1,3 @@
+import { ExpressionNode } from '../ast';
+declare function parse(source: string): ExpressionNode;
+export { parse };

package/dist/rsql/parser/lexer/LexerContext.d.ts

@@ -0,0 +1,8 @@
+interface LexerContext {
+    position: number;
+    readonly buffer: string;
+    readonly length: number;
+}
+declare function createLexerContext(input: string): LexerContext;
+export default LexerContext;
+export { createLexerContext };

package/dist/rsql/parser/lexer/LexerProcessor.d.ts

@@ -0,0 +1,8 @@
+import Token from './Token';
+import LexerContext from './LexerContext';
+type LexerProcessor<TOutput> = (context: LexerContext) => TOutput;
+type SeekProcessor<TToken extends Token = Token> = LexerProcessor<TToken | null>;
+type SkipProcessor = LexerProcessor<void>;
+type ScanProcessor<TSymbol extends string> = LexerProcessor<TSymbol | null>;
+export default LexerProcessor;
+export type { SeekProcessor, SkipProcessor, ScanProcessor };

package/dist/rsql/parser/lexer/Token.d.ts

@@ -0,0 +1,38 @@
+import { ComparisonOperator, LogicOperator } from '../../ast';
+declare const TokenType: {
+    readonly UNQUOTED: "UNQUOTED";
+    readonly QUOTED: "QUOTED";
+    readonly PARENTHESIS: "PARENTHESIS";
+    readonly OPERATOR: "OPERATOR";
+    readonly END: "END";
+};
+interface Token<TType extends string = string, TValue = any> {
+    readonly type: TType;
+    readonly value: TValue;
+    readonly position: number;
+}
+type UnquotedToken = Token<typeof TokenType.UNQUOTED, string>;
+type QuotedToken = Token<typeof TokenType.QUOTED, string>;
+type ParenthesisToken = Token<typeof TokenType.PARENTHESIS, '(' | ')'>;
+type OperatorToken = Token<typeof TokenType.OPERATOR, ComparisonOperator | LogicOperator>;
+type EndToken = Token<typeof TokenType.END, 'END'>;
+declare function createUnquotedToken(value: string, position: number): UnquotedToken;
+declare function createQuotedToken(value: string, position: number): QuotedToken;
+declare function createParenthesisToken(value: '(' | ')', position: number): ParenthesisToken;
+declare function createOperatorToken(value: ComparisonOperator | LogicOperator, position: number): OperatorToken;
+declare function createEndToken(position: number): EndToken;
+type AnyToken = UnquotedToken | QuotedToken | ParenthesisToken | OperatorToken | EndToken;
+declare function isToken(candidate: object): candidate is Token;
+declare function isUnquotedToken(candidate: object): candidate is UnquotedToken;
+declare function isQuotedToken(candidate: object): candidate is QuotedToken;
+declare function isParenthesisToken(candidate: object): candidate is ParenthesisToken;
+declare function isOpenParenthesisToken(candidate: object): candidate is ParenthesisToken;
+declare function isCloseParenthesisToken(candidate: object): candidate is ParenthesisToken;
+declare function isOperatorToken(candidate: object): candidate is OperatorToken;
+declare function isComparisonOperatorToken(candidate: object): candidate is OperatorToken;
+declare function isOrOperatorToken(candidate: object): candidate is OperatorToken;
+declare function isAndOperatorToken(candidate: object): candidate is OperatorToken;
+declare function isEndToken(candidate: object): candidate is EndToken;
+export default Token;
+export { createUnquotedToken, createQuotedToken, createParenthesisToken, createOperatorToken, createEndToken, isToken, isUnquotedToken, isQuotedToken, isParenthesisToken, isOpenParenthesisToken, isCloseParenthesisToken, isOperatorToken, isComparisonOperatorToken, isOrOperatorToken, isAndOperatorToken, isEndToken, };
+export type { AnyToken, UnquotedToken, QuotedToken, ParenthesisToken, OperatorToken, EndToken };

package/dist/rsql/parser/lexer/lex.d.ts

@@ -0,0 +1,3 @@
+import { AnyToken } from './Token';
+declare function lex(input: string): AnyToken[];
+export default lex;

package/dist/rsql/parser/lexer/processors/scanNonReservedSymbol.d.ts

@@ -0,0 +1,3 @@
+import { ScanProcessor } from '../LexerProcessor';
+declare function createScanNonReservedSymbol<TSymbol extends string>(symbols: ReadonlyArray<TSymbol>): ScanProcessor<TSymbol>;
+export { createScanNonReservedSymbol };

package/dist/rsql/parser/lexer/processors/scanSymbol.d.ts

@@ -0,0 +1,3 @@
+import { ScanProcessor } from '../LexerProcessor';
+declare function createScanSymbol<TSymbol extends string>(symbols: ReadonlyArray<TSymbol>): ScanProcessor<TSymbol>;
+export { createScanSymbol };

package/dist/rsql/parser/lexer/processors/seekAnyToken.d.ts

@@ -0,0 +1,4 @@
+import { AnyToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekAnyToken: SeekProcessor<AnyToken>;
+export default seekAnyToken;

package/dist/rsql/parser/lexer/processors/seekComparisonCustomOperatorToken.d.ts

@@ -0,0 +1,4 @@
+import { OperatorToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekComparisonCustomOperatorToken: SeekProcessor<OperatorToken>;
+export default seekComparisonCustomOperatorToken;

package/dist/rsql/parser/lexer/processors/seekComparisonOperatorToken.d.ts

@@ -0,0 +1,4 @@
+import { OperatorToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekComparisonOperatorToken: SeekProcessor<OperatorToken>;
+export default seekComparisonOperatorToken;

package/dist/rsql/parser/lexer/processors/seekLogicCanonicalOperatorToken.d.ts

@@ -0,0 +1,4 @@
+import { OperatorToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekLogicCanonicalOperatorToken: SeekProcessor<OperatorToken>;
+export default seekLogicCanonicalOperatorToken;

package/dist/rsql/parser/lexer/processors/seekLogicVerboseOperatorToken.d.ts

@@ -0,0 +1,4 @@
+import { SeekProcessor } from '../LexerProcessor';
+import { OperatorToken } from '../Token';
+declare const seekLogicVerboseOperatorToken: SeekProcessor<OperatorToken>;
+export default seekLogicVerboseOperatorToken;

package/dist/rsql/parser/lexer/processors/seekParenthesisToken.d.ts

@@ -0,0 +1,4 @@
+import { ParenthesisToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekParenthesisToken: SeekProcessor<ParenthesisToken>;
+export default seekParenthesisToken;

package/dist/rsql/parser/lexer/processors/seekQuotedToken.d.ts

@@ -0,0 +1,4 @@
+import { QuotedToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekQuotedToken: SeekProcessor<QuotedToken>;
+export default seekQuotedToken;

package/dist/rsql/parser/lexer/processors/seekUnquotedToken.d.ts

@@ -0,0 +1,4 @@
+import { UnquotedToken } from '../Token';
+import { SeekProcessor } from '../LexerProcessor';
+declare const seekUnquotedToken: SeekProcessor<UnquotedToken>;
+export default seekUnquotedToken;

package/dist/rsql/parser/lexer/processors/skipWhitespace.d.ts

@@ -0,0 +1,3 @@
+import { SkipProcessor } from '../LexerProcessor';
+declare const skipWhitespace: SkipProcessor;
+export default skipWhitespace;

package/dist/types/OptionsResult.d.ts

@@ -0,0 +1,8 @@
+export interface OptionsResult<T> {
+    data: T[];
+    total: number;
+    page?: number;
+    size?: number;
+    hasNext?: boolean;
+    hasPrevious?: boolean;
+}

package/dist/types/filter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Filter and Query types for Archbase Core
+ */
+export interface IQueryFilterEntity {
+    id?: any;
+    companyId?: any;
+    filter?: string;
+    name?: string;
+    description?: string;
+    userOwner?: string;
+    shared?: boolean;
+    readOnly?: boolean;
+    componentId?: string;
+}
+export declare class QueryFilterEntity implements IQueryFilterEntity {
+    id?: any;
+    companyId?: any;
+    filter?: string;
+    name?: string;
+    description?: string;
+    userOwner?: string;
+    shared?: boolean;
+    readOnly?: boolean;
+    componentId?: string;
+    constructor(data?: Partial<IQueryFilterEntity>);
+}
+export type DelegatorCallback = (error: string | null, result?: any) => void;
+export interface ArchbaseQueryFilterDelegator {
+    onSaveFilter?: DelegatorCallback;
+    onRemoveFilter?: DelegatorCallback;
+    onSelectFilter?: DelegatorCallback;
+    onClearFilter?: DelegatorCallback;
+    addNewFilter?(filter: IQueryFilterEntity, onResult: DelegatorCallback): void;
+    saveFilter?(filter: IQueryFilterEntity, onResult: DelegatorCallback): void;
+    removeFilterBy?(filter: IQueryFilterEntity, onResult: DelegatorCallback): void;
+    getFilterById?(id: any): IQueryFilterEntity | undefined;
+    getFirstFilter?(): IQueryFilterEntity | undefined;
+    getFilters?(): IQueryFilterEntity[];
+}
+export interface ArchbaseQueryFilter {
+    filter?: any;
+    sort?: any;
+    searchText?: string;
+    activeFilterIndex?: number;
+    quickFilterText?: string;
+    activeFilter?: IQueryFilterEntity;
+}
+export declare const FILTER_TYPE: {
+    readonly QUICK: "QUICK";
+    readonly NORMAL: "NORMAL";
+    readonly ADVANCED: "ADVANCED";
+};
+export type FilterType = typeof FILTER_TYPE[keyof typeof FILTER_TYPE];
+export declare const QUICK: "QUICK";
+export declare const NORMAL: "NORMAL";
+export declare const ADVANCED: "ADVANCED";

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { ComponentDefinition } from './types';
+export * from './filter';
+export * from './querybuilder';
+export * from './OptionsResult';
+export * from './token';

package/dist/types/querybuilder.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Extended types for QueryBuilder system (specific to querybuilder components)
+ * Base types are in filter.ts to avoid duplication
+ */
+export type PositionType = 'filter' | 'fields' | 'range' | undefined;
+export type RangeType = 'month' | 'week' | 'range' | 'day' | undefined;
+export type DataType = 'string' | 'number' | 'date' | 'date_time' | 'time' | 'boolean';
+export interface FilterValue {
+    label: string;
+    value: string;
+}
+export interface SortField {
+    name: string;
+    selected: boolean;
+    order: number;
+    asc_desc: string;
+    label: string;
+}
+export interface Field {
+    name: string;
+    label: string;
+    dataType: DataType;
+    operator: string;
+    quickFilter: boolean;
+    quickFilterSort: boolean;
+    sortable: boolean;
+    listValues: FilterValue[];
+    searchComponent?: any;
+    searchField?: any;
+    nameSql?: string;
+}
+export interface Rule {
+    field: string;
+    operator: string;
+    value: any;
+    condition?: string;
+}
+export interface Filter {
+    id: string;
+    selectedFields: Field[];
+    quickFilterText: string;
+    quickFilterFieldsText: string;
+    rules: Rule[];
+    condition: string;
+    filterType: any;
+}
+export interface Sort {
+    quickFilterSort: string;
+    sortFields: SortField[];
+    activeIndex: number;
+}
+export interface ArchbaseQueryBuilderFilter {
+    id?: number;
+    filter: Filter;
+    sort: Sort;
+    name?: string;
+    viewName?: string;
+    apiVersion?: string;
+    selectedFields?: Field[];
+}
+export interface FilterOptions {
+    currentFilter?: ArchbaseQueryBuilderFilter;
+    activeFilterIndex: number;
+    enabledAdvancedFilter: boolean;
+    apiVersion: string;
+    viewName: string;
+    componentName: string;
+    onApplyFilter?: (currentFilter: ArchbaseQueryBuilderFilter, index: number) => void;
+}
+export declare const QUICK_FILTER_INDEX = -2;
+export declare const NEW_FILTER_INDEX = -1;
+export declare const OP_NULL = "null";
+export declare const OP_NOT_NULL = "notNull";
+export declare const OP_CONTAINS = "contains";
+export declare const OP_STARTSWITH = "startsWith";
+export declare const OP_ENDSWITH = "endsWith";
+export declare const OP_EQUALS = "=";
+export declare const OP_NOT_EQUALS = "!=";
+export declare const OP_GREATER = ">";
+export declare const OP_LESS = "<";
+export declare const OP_GREATER_OR_EQUAL = ">=";
+export declare const OP_LESS_OR_EQUAL = "<=";
+export declare const OP_BETWEEN = "between";
+export declare const OP_IN_LIST = "inList";
+export declare const OP_NOT_IN_LIST = "notInList";

package/dist/types/token.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Interface representing an access token used for authentication
+ */
+export interface ArchbaseAccessToken {
+    token_type: string;
+    scope: string;
+    expires_in: number;
+    ext_expires_in: number;
+    access_token: string;
+    refresh_token: string;
+    id_token: string;
+}
+/**
+ * Interface representing username and password credentials
+ */
+export interface ArchbaseUsernameAndPassword {
+    username: string;
+    password: string;
+    remember: boolean;
+}
+/**
+ * Interface representing a user in the system
+ */
+export interface ArchbaseUser {
+    id: string;
+    displayName: string;
+    email: string;
+    photo: string;
+    isAdmin: boolean;
+}
+/**
+ * Interface for token management operations
+ */
+export interface ArchbaseTokenManager {
+    saveUsernameAndPassword(username: string, password: string): void;
+    getUsernameAndPassword(): ArchbaseUsernameAndPassword | null;
+    saveUsername(username: string): void;
+    getUsername(): string | null;
+    saveToken(accessToken?: ArchbaseAccessToken): void;
+    clearToken(): void;
+    clearUsernameAndPassword(): void;
+    getToken(): ArchbaseAccessToken | null;
+    isTokenExpired(token?: ArchbaseAccessToken, expirationThreshold?: number): boolean;
+    /** Salva o contexto da autenticação como string JSON */
+    saveContext?(context: string): void;
+    /** Recupera o contexto salvo */
+    getContext?(): string | null;
+    /** Limpa contexto */
+    clearContext?(): void;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export interface ComponentDefinition {
+    type: React.ElementType;
+    props?: any;
+}