@opra/common 0.33.12 → 1.0.0-alpha.1

package/types/document/http/http-operation.d.ts

@@ -0,0 +1,84 @@
+import { Combine, StrictOmit, ThunkAsync, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import type { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { HttpOperationDecorator } from '../decorators/http-operation.decorator.js';
+import type { HttpController } from './http-controller.js';
+import type { HttpOperationResponse } from './http-operation-response.js';
+import type { HttpParameter } from './http-parameter.js';
+import type { HttpRequestBody } from './http-request-body.js';
+/**
+ * @namespace HttpOperation
+ */
+export declare namespace HttpOperation {
+    interface Metadata extends Pick<OpraSchema.HttpOperation, 'description' | 'path' | 'method' | 'composition' | 'compositionOptions'> {
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        parameters?: HttpParameter.Metadata[];
+        responses?: HttpOperationResponse.Metadata[];
+        requestBody?: HttpRequestBody.Metadata;
+        immediateFetch?: boolean;
+    }
+    interface Options extends Partial<Pick<Metadata, 'path' | 'description' | 'method' | 'immediateFetch'>> {
+        requestBody?: HttpRequestBody.Options;
+    }
+    interface InitArguments extends Combine<{
+        name: string;
+        types?: DataType[];
+    }, Pick<Metadata, 'description' | 'path' | 'method' | 'composition' | 'compositionOptions' | 'immediateFetch'>> {
+    }
+}
+/**
+ * Type definition for HttpOperation
+ * @class HttpOperation
+ */
+export interface HttpOperationStatic {
+    /**
+     * Class constructor of HttpOperation
+     * @param controller
+     * @param args
+     */
+    new (controller: HttpController, args: HttpOperation.InitArguments): HttpOperation;
+    /**
+     * Property decorator
+     * @param options
+     */ <T extends HttpOperation.Options>(options?: T): HttpOperationDecorator;
+    prototype: HttpOperation;
+    GET(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    DELETE(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    HEAD(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    OPTIONS(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    PATCH(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    POST(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    PUT(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+    SEARCH(options?: StrictOmit<HttpOperation.Options, 'method'>): HttpOperationDecorator;
+}
+/**
+ * @class HttpOperation
+ */
+export interface HttpOperation extends HttpOperationClass {
+}
+/**
+ *  HttpOperation
+ */
+export declare const HttpOperation: HttpOperationStatic;
+/**
+ * @class HttpOperation
+ */
+declare class HttpOperationClass extends DocumentElement {
+    readonly owner: HttpController;
+    readonly name: string;
+    method: OpraSchema.HttpMethod;
+    description?: string;
+    path?: string;
+    types: DataTypeMap;
+    parameters: HttpParameter[];
+    responses: HttpOperationResponse[];
+    requestBody?: HttpRequestBody;
+    composition?: string;
+    compositionOptions?: Record<string, any>;
+    findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
+    toJSON(): OpraSchema.HttpOperation;
+}
+export {};

package/types/document/http/http-parameter.d.ts

@@ -0,0 +1,50 @@
+import { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
+import type { OpraSchema } from '../../schema/index.js';
+import { HttpParameterLocation } from '../../schema/types.js';
+import { DocumentElement } from '../common/document-element.js';
+import { Value } from '../common/value.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+/**
+ * @namespace HttpParameter
+ */
+export declare namespace HttpParameter {
+    interface Metadata extends StrictOmit<OpraSchema.HttpParameter, 'type'> {
+        name: string | RegExp;
+        type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }
+    interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
+        type?: string | TypeThunkAsync | object;
+    }
+    interface InitArguments extends Combine<{
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition for HttpParameter
+ * @class HttpParameter
+ */
+interface HttpParameterStatic {
+    new (owner: DocumentElement, args: HttpParameter.InitArguments): HttpParameter;
+    prototype: HttpParameter;
+}
+/**
+ * Type definition of HttpParameter prototype
+ * @interface HttpParameter
+ */
+export interface HttpParameter extends HttpParameterClass {
+}
+export declare const HttpParameter: HttpParameterStatic;
+/**
+ * @class HttpParameter
+ */
+declare class HttpParameterClass extends Value {
+    readonly owner: DocumentElement;
+    deprecated?: boolean | string;
+    required?: boolean;
+    arraySeparator?: string;
+    location: HttpParameterLocation;
+    toJSON(): OpraSchema.HttpParameter;
+}
+export {};

package/types/document/http/http-request-body.d.ts

@@ -0,0 +1,31 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { HttpMediaType } from './http-media-type.js';
+import type { HttpOperation } from './http-operation';
+/**
+ * @namespace HttpRequestBody
+ */
+export declare namespace HttpRequestBody {
+    interface Metadata extends Partial<StrictOmit<OpraSchema.HttpRequestBody, 'content'>> {
+        content: HttpMediaType.Metadata[];
+        immediateFetch?: boolean;
+    }
+    interface Options extends Partial<StrictOmit<OpraSchema.HttpRequestBody, 'content'>> {
+        immediateFetch?: boolean;
+    }
+}
+/**
+ * @class HttpRequestBody
+ */
+export declare class HttpRequestBody extends DocumentElement {
+    readonly owner: HttpOperation;
+    description?: string;
+    content: HttpMediaType[];
+    required?: boolean;
+    maxContentSize?: number;
+    immediateFetch?: boolean;
+    partial?: boolean | 'deep';
+    constructor(owner: HttpOperation);
+    toJSON(): OpraSchema.HttpRequestBody;
+}

package/types/document/http/http-status-range.d.ts

@@ -0,0 +1,14 @@
+import { OpraSchema } from '../../schema/index.js';
+/**
+ * @class HttpStatusRange
+ */
+export declare class HttpStatusRange {
+    start: number;
+    end: number;
+    constructor(value: string);
+    constructor(start: number, end?: number);
+    constructor(init: Pick<HttpStatusRange, 'start' | 'end'>);
+    get distance(): number;
+    toString(): string;
+    toJSON(): OpraSchema.HttpStatusRange | number;
+}

package/types/document/index.d.ts

@@ -1,28 +1,39 @@
 import 'reflect-metadata';
-export * from './constants.js';
+import * as DataTypeFactory_ from './factory/data-type.factory.js';
+import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
-export * from './type-document.js';
-export * from './factory/type-document-factory.js';
-export * from './factory/api-document-factory.js';
-export * from './data-type/data-type.js';
+export * from './constants.js';
+export * from './common/api-base.js';
+export * from './common/data-type-map.js';
+export * from './common/document-element.js';
+export * from './common/document-init-context.js';
+export * from './common/document-node.js';
+export * from './common/opra-document-error.js';
 export * from './data-type/complex-type.js';
-export * from './data-type/field.js';
+export * from './data-type/data-type.js';
 export * from './data-type/enum-type.js';
+export * from './data-type/api-field.js';
 export * from './data-type/mapped-type.js';
-export * from './data-type/simple-type.js';
 export * from './data-type/mixin-type.js';
-export * from './resource/action.js';
-export * from './resource/collection.js';
-export * from './resource/container.js';
-export * from './resource/crud-resource.js';
-export * from './resource/endpoint.js';
-export * from './resource/crud-operation.js';
-export * from './resource/parameter.js';
-export * from './resource/resource.js';
-export * from './resource/singleton.js';
-export * from './resource/storage.js';
-export * from './resource/enums/metadata-mode.enum.js';
-export * from './resource/types/operation-result.type.js';
-export * from './interfaces/collection.interface.js';
-export * from './interfaces/singleton.interface.js';
-export * from './interfaces/storage.interface.js';
+export * from './data-type/omit-type.js';
+export * from './data-type/partial-type.js';
+export * from './data-type/pick-type.js';
+export * from './data-type/required-type.js';
+export * from './data-type/simple-type.js';
+export * from './data-type/primitive-types/index.js';
+export * from './data-type/extended-types/index.js';
+export * from './decorators/http-operation-entity.decorator.js';
+export * from './factory/api-document.factory.js';
+export * from './http/http-api.js';
+export * from './http/http-media-type.js';
+export * from './http/http-multipart-field.js';
+export * from './http/http-operation.js';
+export * from './http/http-operation-response.js';
+export * from './http/http-parameter.js';
+export * from './http/http-request-body.js';
+export * from './http/http-controller.js';
+export * from './http/http-status-range.js';
+export declare namespace classes {
+    export import HttpApiFactory = HttpApiFactory_.HttpApiFactory;
+    export import DataTypeFactory = DataTypeFactory_.DataTypeFactory;
+}

package/types/document/utils/parse-regexp.util.d.ts

@@ -0,0 +1,4 @@
+export declare function parseRegExp(str: string, options?: {
+    includeFlags?: string;
+    excludeFlags?: string;
+}): RegExp;

package/types/exception/http-errors/bad-request.error.d.ts

@@ -1,11 +1,11 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 400 Bad Request
  * The server cannot or will not process the request due to something that is perceived to be a client error
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
-export declare class BadRequestError extends OpraException {
+export declare class BadRequestError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/conflict.error.d.ts

@@ -1,10 +1,10 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 409 Conflict
  * This response is sent when a request conflicts with the current state of the server.
  */
-export declare class ConflictError extends OpraException {
+export declare class ConflictError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/failed-dependency.error.d.ts

@@ -1,10 +1,10 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 424 Failed Dependency
  * The request failed due to failure of a previous request.
  */
-export declare class FailedDependencyError extends OpraException {
+export declare class FailedDependencyError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/forbidden.error.d.ts

@@ -1,13 +1,13 @@
 import { HttpStatusCode } from '../../http/index.js';
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 403 Forbidden
  * The client does not have access rights to the content; that is, it is unauthorized,
  * so the server is refusing to give the requested resource. Unlike 401 Unauthorized,
  * the client's identity is known to the server.
  */
-export declare class ForbiddenError extends OpraException {
+export declare class ForbiddenError extends OpraHttpError {
     status: HttpStatusCode;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/internal-server.error.d.ts

@@ -1,10 +1,10 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 500 Internal Server Error
  * The server has encountered a situation it does not know how to handle.
  */
-export declare class InternalServerError extends OpraException {
+export declare class InternalServerError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/method-not-allowed.error.d.ts

@@ -1,11 +1,11 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 405 Method Not Allowed
  * The request method is known by the server but is not supported by the target resource.
  * For example, an API may not allow calling DELETE to remove a resource.
  */
-export declare class MethodNotAllowedError extends OpraException {
+export declare class MethodNotAllowedError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/not-acceptable.error.d.ts

@@ -1,11 +1,11 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 406 Not Acceptable
  * This response is sent when the web server, after performing server-driven content negotiation,
  * doesn't find any content that conforms to the criteria given by the user agent.
  */
-export declare class NotAcceptableError extends OpraException {
+export declare class NotAcceptableError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/not-found.error.d.ts

@@ -1,5 +1,5 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 404 Not Found
  * The server can not find the requested resource. In the browser, this means the URL is not recognized.
@@ -8,7 +8,7 @@ import { OpraException } from '../opra-exception.js';
  * from an unauthorized client. This response code is probably the most well known due to its
  * frequent occurrence on the web.
  */
-export declare class NotFoundError extends OpraException {
+export declare class NotFoundError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/{resource-errors → http-errors}/permission.error.d.ts

@@ -1,5 +1,5 @@
 import { ErrorIssue } from '../error-issue.js';
-import { ForbiddenError } from '../http-errors/forbidden.error.js';
+import { ForbiddenError } from './forbidden.error.js';
 /**
  * 403 Forbidden
  * The client does not have access rights to the content; that is, it is unauthorized,

package/types/exception/http-errors/resource-conflict.error.d.ts

@@ -0,0 +1,5 @@
+import { OpraHttpError } from '../opra-http-error.js';
+export declare class ResourceConflictError extends OpraHttpError {
+    status: number;
+    constructor(resource: string, fields: string | string[], cause?: Error);
+}

package/types/exception/{resource-errors → http-errors}/resource-not.available.error.d.ts

@@ -1,8 +1,8 @@
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * The server cannot find the requested resource.
  * This can also mean that the endpoint is valid but the resource itself does not exist.
  */
-export declare class ResourceNotAvailableError extends OpraException {
+export declare class ResourceNotAvailableError extends OpraHttpError {
     constructor(resource: string, keyValue?: any, cause?: Error);
 }

package/types/exception/http-errors/unauthorized.error.d.ts

@@ -1,11 +1,11 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 401 Unauthorized
  * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated".
  * That is, the client must authenticate itself to get the requested response.
  */
-export declare class UnauthorizedError extends OpraException {
+export declare class UnauthorizedError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/unprocessable-entity.error.d.ts

@@ -1,10 +1,10 @@
 import { ErrorIssue } from '../error-issue.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 422 Unprocessable Entity
  * The request was well-formed but was unable to be followed due to semantic errors.
  */
-export declare class UnprocessableEntityError extends OpraException {
+export declare class UnprocessableEntityError extends OpraHttpError {
     status: number;
     protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/index.d.ts

@@ -1,6 +1,6 @@
 export * from './opra-exception.js';
+export * from './opra-http-error.js';
 export * from './error-issue.js';
-export * from './wrap-exception.js';
 export * from './issue-severity.enum.js';
 export * from './http-errors/bad-request.error.js';
 export * from './http-errors/conflict.error.js';
@@ -12,6 +12,6 @@ export * from './http-errors/not-acceptable.error.js';
 export * from './http-errors/not-found.error.js';
 export * from './http-errors/unauthorized.error.js';
 export * from './http-errors/unprocessable-entity.error.js';
-export * from './resource-errors/permission.error.js';
-export * from './resource-errors/resource-conflict.error.js';
-export * from './resource-errors/resource-not.available.error.js';
+export * from './http-errors/permission.error.js';
+export * from './http-errors/resource-conflict.error.js';
+export * from './http-errors/resource-not.available.error.js';

package/types/exception/opra-exception.d.ts

@@ -5,15 +5,11 @@ import { IssueSeverity } from './issue-severity.enum.js';
  */
 export declare class OpraException extends Error {
     cause?: Error;
-    status: number;
     severity: IssueSeverity.Type;
     system?: string;
     code?: string;
     details?: any;
-    constructor();
-    constructor(issue: string | Partial<ErrorIssue> | Error, status?: number);
-    constructor(issue: string | Partial<ErrorIssue>, cause?: Error, status?: number);
-    setStatus(status: number): this;
+    constructor(issue: string | Partial<ErrorIssue> | Error, cause?: Error);
     toString(): string;
     toJSON(): ErrorIssue;
     protected init(issue?: Partial<ErrorIssue>): void;

package/types/exception/opra-http-error.d.ts

@@ -0,0 +1,13 @@
+import { ErrorIssue } from './error-issue.js';
+import { OpraException } from './opra-exception.js';
+/**
+ * Defines the base Opra exception, which is handled by the default Exceptions Handler.
+ */
+export declare class OpraHttpError extends OpraException {
+    status: number;
+    constructor();
+    constructor(issue: string | Partial<ErrorIssue> | Error, status?: number);
+    constructor(issue: string | Partial<ErrorIssue>, cause?: Error, status?: number);
+    setStatus(status: number): this;
+    protected initError(issue: Error): void;
+}

package/types/filter/antlr/OpraFilterLexer.d.ts

@@ -1,4 +1,4 @@
-import { ATN, CharStream, DFA, Lexer } from "@browsery/antlr4";
+import { ATN, CharStream, DFA, Lexer } from '@browsery/antlr4';
 export default class OpraFilterLexer extends Lexer {
     static readonly T__0 = 1;
     static readonly T__1 = 2;

package/types/filter/antlr/OpraFilterListener.d.ts

@@ -1,5 +1,5 @@
-import { ParseTreeListener } from "@browsery/antlr4";
-import { ArithmeticOperatorContext, ArrayValueContext, BooleanContext, BooleanLiteralContext, ComparisonExpressionContext, ComparisonLeftContext, ComparisonOperatorContext, ComparisonRightContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantContext, IdentifierContext, InfinityContext, InfinityLiteralContext, LogicalExpressionContext, LogicalOperatorContext, NegativeExpressionContext, NullContext, NullLiteralContext, NumberLiteralContext, ParenthesizedExpressionContext, ParenthesizedItemContext, PolarityOperatorContext, QualifiedIdentifierContext, RootContext, StringLiteralContext, TimeLiteralContext } from "./OpraFilterParser.js";
+import { ParseTreeListener } from '@browsery/antlr4';
+import { ArithmeticOperatorContext, ArrayValueContext, BooleanContext, BooleanLiteralContext, ComparisonExpressionContext, ComparisonLeftContext, ComparisonOperatorContext, ComparisonRightContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantContext, IdentifierContext, InfinityContext, InfinityLiteralContext, LogicalExpressionContext, LogicalOperatorContext, NegativeExpressionContext, NullContext, NullLiteralContext, NumberLiteralContext, ParenthesizedExpressionContext, ParenthesizedItemContext, PolarityOperatorContext, QualifiedIdentifierContext, RootContext, StringLiteralContext, TimeLiteralContext } from './OpraFilterParser.js';
 /**
  * This interface defines a complete listener for a parse tree produced by
  * `OpraFilterParser`.

package/types/filter/antlr/OpraFilterParser.d.ts

@@ -1,6 +1,6 @@
 import { ATN, DFA, FailedPredicateException, Parser, ParserRuleContext, RuleContext, TerminalNode, TokenStream } from '@browsery/antlr4';
-import type OpraFilterListener from "./OpraFilterListener.js";
-import type OpraFilterVisitor from "./OpraFilterVisitor.js";
+import type OpraFilterListener from './OpraFilterListener.js';
+import type OpraFilterVisitor from './OpraFilterVisitor.js';
 export default class OpraFilterParser extends Parser {
     static readonly T__0 = 1;
     static readonly T__1 = 2;

package/types/filter/antlr/OpraFilterVisitor.d.ts

@@ -1,5 +1,5 @@
 import { ParseTreeVisitor } from '@browsery/antlr4';
-import { ArithmeticOperatorContext, ArrayValueContext, BooleanContext, BooleanLiteralContext, ComparisonExpressionContext, ComparisonLeftContext, ComparisonOperatorContext, ComparisonRightContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantContext, IdentifierContext, InfinityContext, InfinityLiteralContext, LogicalExpressionContext, LogicalOperatorContext, NegativeExpressionContext, NullContext, NullLiteralContext, NumberLiteralContext, ParenthesizedExpressionContext, ParenthesizedItemContext, PolarityOperatorContext, QualifiedIdentifierContext, RootContext, StringLiteralContext, TimeLiteralContext } from "./OpraFilterParser.js";
+import { ArithmeticOperatorContext, ArrayValueContext, BooleanContext, BooleanLiteralContext, ComparisonExpressionContext, ComparisonLeftContext, ComparisonOperatorContext, ComparisonRightContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantContext, IdentifierContext, InfinityContext, InfinityLiteralContext, LogicalExpressionContext, LogicalOperatorContext, NegativeExpressionContext, NullContext, NullLiteralContext, NumberLiteralContext, ParenthesizedExpressionContext, ParenthesizedItemContext, PolarityOperatorContext, QualifiedIdentifierContext, RootContext, StringLiteralContext, TimeLiteralContext } from './OpraFilterParser.js';
 /**
  * This interface defines a complete generic visitor for a parse tree produced
  * by `OpraFilterParser`.

package/types/filter/ast/terms/qualified-identifier.d.ts

@@ -1,5 +1,5 @@
+import type { ApiField } from '../../../document/data-type/api-field.js';
 import { DataType } from '../../../document/data-type/data-type.js';
-import type { ApiField } from '../../../document/data-type/field.js';
 import { Literal } from '../abstract/literal.js';
 export declare class QualifiedIdentifier extends Literal {
     dataType: DataType;

package/types/filter/filter-rules.d.ts

@@ -0,0 +1,24 @@
+import { StrictOmit } from 'ts-gems';
+import type { ComplexType } from '../document/index.js';
+import { OpraFilter } from '../filter/index.js';
+import { ResponsiveMap } from '../helpers/index.js';
+import { OpraSchema } from '../schema/index.js';
+export declare namespace FilterRules {
+    interface Options {
+        caseSensitive?: boolean;
+    }
+    interface Rule {
+        operators?: OpraFilter.ComparisonOperator[];
+        description?: string;
+    }
+}
+export declare class FilterRules {
+    protected _rules: ResponsiveMap<FilterRules.Rule>;
+    constructor(rules?: Record<string, FilterRules.Rule>, options?: FilterRules.Options);
+    set(fieldName: string, options?: Partial<StrictOmit<FilterRules.Rule, 'operators'>> & {
+        operators?: OpraFilter.ComparisonOperator[] | string;
+    }): void;
+    normalizeFilter(filter: OpraSchema.Field.QualifiedName | OpraFilter.Expression, dataType?: ComplexType): OpraFilter.Expression | undefined;
+    toJSON(): Record<string, FilterRules.Rule>;
+    [Symbol.iterator](): IterableIterator<[string, FilterRules.Rule]>;
+}

package/types/filter/filter-tree-visitor.d.ts

@@ -1,9 +1,8 @@
-import type { ParseTreeVisitor as TParseTreeVisitor, RuleNode } from '@browsery/antlr4';
+import { ParseTreeVisitor, type RuleNode } from '@browsery/antlr4';
 import { ArrayValueContext, BooleanLiteralContext, ComparisonExpressionContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantContext, LogicalExpressionContext, NegativeExpressionContext, NumberLiteralContext, ParenthesizedExpressionContext, ParenthesizedItemContext, QualifiedIdentifierContext, RootContext, StringLiteralContext, TimeLiteralContext } from './antlr/OpraFilterParser.js';
 import OpraFilterVisitor from './antlr/OpraFilterVisitor.js';
 import { ArrayExpression, BooleanLiteral, DateLiteral, LogicalExpression, NegativeExpression, NullLiteral, NumberLiteral, ParenthesizedExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from './ast/index.js';
 import { ExternalConstant } from './ast/terms/external-constant.js';
-declare const ParseTreeVisitor: typeof TParseTreeVisitor;
 export declare class FilterTreeVisitor extends ParseTreeVisitor<any> implements OpraFilterVisitor<any> {
     private _timeZone?;
     constructor(options?: {
@@ -29,4 +28,3 @@ export declare class FilterTreeVisitor extends ParseTreeVisitor<any> implements
     visitTimeLiteral(ctx: TimeLiteralContext): TimeLiteral;
     visitArrayValue(ctx: ArrayValueContext): ArrayExpression;
 }
-export {};

package/types/helpers/function-utils.d.ts

@@ -1,4 +1,2 @@
-import { Type } from 'ts-gems';
-import { ThunkAsync } from '../types.js';
-export declare function resolveThunk(thunk: ThunkAsync<any>): Promise<any>;
-export declare function resolveClass(thunk: ThunkAsync<Type>): Promise<Type>;
+import { ThunkAsync } from 'ts-gems';
+export declare function resolveThunk(thunk: ThunkAsync<any> | Promise<any>): Promise<any>;

package/types/helpers/get-stack-filename.d.ts

@@ -1 +1,2 @@
 export declare function getStackFileName(position?: number): string;
+export declare function getErrorStack(position?: number): string;

package/types/helpers/index.d.ts

@@ -1,8 +1,8 @@
+import './monkey-patches.js';
 export * from './function-utils.js';
 export * from './get-stack-filename.js';
-export * from './is-url-string.js';
 export * from './mixin-utils.js';
 export * from './object-utils.js';
-export * from './path-to-object-tree.js';
+export * from './parse-fields-projection.js';
 export * from './responsive-map.js';
 export * from './type-guards.js';

package/types/helpers/parse-fields-projection.d.ts

@@ -0,0 +1,11 @@
+export declare class FieldsProjection {
+    [key: string]: FieldsProjection.Item;
+}
+export declare namespace FieldsProjection {
+    class Item {
+        sign?: string;
+        projection?: FieldsProjection;
+    }
+}
+export declare function parseFieldsProjection(projection: string | string[], keepCase?: boolean): FieldsProjection | undefined;
+export declare function parse(input: string, target: FieldsProjection): void;