@openfga/syntax-transformer/dist/errors.d.ts

Javascript implementation of ANTLR Grammar for the OpenFGA DSL and parser from and to the OpenFGA JSON Syntax

import { RecognitionException } from "antlr4";
export declare enum ValidationError {
    SchemaVersionRequired = "schema-version-required",
    SchemaVersionUnsupported = "schema-version-unsupported",
    ReservedTypeKeywords = "reserved-type-keywords",
    ReservedRelationKeywords = "reserved-relation-keywords",
    SelfError = "self-error",
    InvalidName = "invalid-name",
    MissingDefinition = "missing-definition",
    InvalidRelationType = "invalid-relation-type",
    InvalidRelationOnTupleset = "invalid-relation-on-tupleset",
    InvalidType = "invalid-type",
    RelationNoEntrypoint = "relation-no-entry-point",
    TuplesetNotDirect = "tupleuserset-not-direct",
    DuplicatedError = "duplicated-error",
    RequireSchema1_0 = "allowed-type-schema-10",
    AssignableRelationsMustHaveType = "assignable-relation-must-have-type",
    AllowedTypesNotValidOnSchema1_0 = "allowed-type-not-valid-on-schema-1_0",
    InvalidSchema = "invalid-schema",
    InvalidSyntax = "invalid-syntax",
    TypeRestrictionCannotHaveWildcardAndRelation = "type-wildcard-relation",
    ConditionNotDefined = "condition-not-defined",
    ConditionNotUsed = "condition-not-used",
    DifferentNestedConditionName = "different-nested-condition-name",
    MultipleModulesInFile = "multiple-modules-in-file"
}
export interface ErrorProperties {
    line?: {
        start: number;
        end: number;
    };
    column?: {
        start: number;
        end: number;
    };
    msg: string;
    file?: string;
}
export interface ErrorMetadata {
    symbol: string;
    errorType: ValidationError;
    module?: string;
    type?: string;
    relation?: string;
    condition?: string;
    offendingType?: string;
}
/**
 * Abstract base class for syntax and validation exceptions.
 * Line and column numbers returned as part of this are zero based.
 */
export declare abstract class BaseError extends Error {
    properties: ErrorProperties;
    type: string;
    line: {
        start: number;
        end: number;
    } | undefined;
    column: {
        start: number;
        end: number;
    } | undefined;
    file: string | undefined;
    msg: string;
    constructor(properties: ErrorProperties, type: string);
    toString(): string;
}
/**
 * Abstract base class for errors that collate other errors.
 */
export declare abstract class BaseMultiError<T = BaseError> extends Error {
    errors: Array<T>;
    constructor(errors: Array<T>);
    toString(): string;
}
/**
 * Added to listener during syntax parsing, when syntax errors are encountered.
 * Line and column numbers returned as part of this are zero based.
 */
export declare class DSLSyntaxSingleError extends BaseError {
    properties: ErrorProperties;
    metadata?: {
        symbol: string;
    } | undefined;
    constructor(properties: ErrorProperties, metadata?: {
        symbol: string;
    } | undefined, e?: RecognitionException);
    toString(): string;
}
/**
 * Thrown at the end of syntax parsing, collecting all Syntax errors encountered during parsing
 */
export declare class DSLSyntaxError extends BaseMultiError<DSLSyntaxSingleError> {
}
/**
 * Added to reporter as the JSON transformation is being parsed and validated
 * Line and column numbers returned as part of this are zero based.
 */
export declare class ModelValidationSingleError extends BaseError {
    properties: ErrorProperties;
    metadata?: ErrorMetadata | undefined;
    constructor(properties: ErrorProperties, metadata?: ErrorMetadata | undefined);
    toString(): string;
}
/**
 * Thrown at end of checkDSL validation, collecting all encountered validation errors
 */
export declare class ModelValidationError extends BaseMultiError<ModelValidationSingleError> {
}
/**
 * Thrown when improper values are passed.
 */
export declare class ConfigurationError extends Error {
    message: string;
    e: Error;
    constructor(message: string, e: Error);
}
export declare class UnsupportedDSLNestingError extends Error {
    typeName: string;
    relationName: string;
    constructor(typeName: string, relationName: string);
}
export declare class ConditionNameDoesntMatchError extends Error {
    conditionName: string;
    conditionNestedName: string;
    constructor(conditionName: string, conditionNestedName: string);
}
export declare class UnsupportedModularModules extends Error {
    schemaVersion: string;
    constructor(schemaVersion: string);
}
/**
 * Represents an individual error returned during validation of `fga.mod`.
 * Line and column numbers returned as part of this are zero based.
 */
export declare class FGAModFileValidationSingleError extends BaseError {
    properties: ErrorProperties;
    constructor(properties: ErrorProperties);
    toString(): string;
}
/**
 * Thrown when an `fga.mod` file is invalid.
 */
export declare class FGAModFileValidationError extends BaseMultiError {
}
export declare class ModuleTransformationSingleError extends BaseError {
    properties: ErrorProperties;
    metadata?: {
        symbol: string;
    } | undefined;
    constructor(properties: ErrorProperties, metadata?: {
        symbol: string;
    } | undefined);
    toString(): string;
}
/**
 * Thrown when a module is invalid.
 */
export declare class ModuleTransformationError extends BaseMultiError {
}