import { ConditionsMatcher, FieldMatcher, MatchConditions, PureAbility } from '@casl/ability';
import Joi from 'joi';
import { AppDomain, MfaType } from '../type';
import { IdToken } from './auth-id-token';
import { BasicMetadata, BearerMetadata } from './auth-type-verify';
export declare enum AuthTokenType {
    Bearer = "Bearer",
    Basic = "Basic"
}
export declare const _authTokenType: Joi.StringSchema<string>;
export type BaseIdToken = {
    userId: number;
    userLogin: string;
    localeCode: string;
    orgId?: number;
    appDomain?: AppDomain;
    productId?: number;
    extended?: Record<string, any>;
};
export declare const schemaBaseIdToken: {
    userId: Joi.NumberSchema<number>;
    userLogin: Joi.StringSchema<string>;
    localeCode: Joi.StringSchema<string>;
    orgId: Joi.NumberSchema<number>;
    appDomain: Joi.StringSchema<string>;
    productId: Joi.NumberSchema<number>;
    extended: Joi.ObjectSchema<any>;
};
export type RequestMetadata = {
    [x: string]: any;
};
export declare const schemaRequestMetadata: Joi.ObjectSchema<RequestMetadata>;
export type RequestHeaders = {
    get: (key: string) => string;
    localeCode: string;
    roleType?: string;
    remoteIp?: string;
    metadata?: RequestMetadata;
    userAgent?: string;
    userAgentPlatform?: string;
    userAgentClientHints?: string;
    operatorId?: string;
};
export type AuthToken = {
    type: AuthTokenType;
    info: AccessInfo;
    grant?: boolean;
    authMetadata?: {
        bearer?: BearerMetadata;
        basic?: BasicMetadata;
    };
};
export type AccessInfo = {
    token: string;
    auth?: IdToken;
    headers?: RequestHeaders;
    requestedBy?: number;
    requestedByName?: string;
    ability: PureAbility;
    ref?: Record<string, any>;
};
export type AuthDirective = {
    type: AuthTokenType;
    hasAbility?: Rule;
    flag?: boolean;
};
export type Rule = {
    action: string;
    subject: string;
    fields?: string;
    conditions?: RuleConditions;
    inverted?: boolean;
    system?: boolean;
};
export type RuleConditions = {
    [x: string]: any;
    mfa?: MfaSpec;
};
export type MfaSpec = {
    challenges: MfaSpecChallenge[];
};
export type MfaSpecChallenge = {
    type: MfaType;
    optional?: boolean;
};
export declare function generateAbility(rules?: Rule[], vars?: {
    accessInfo?: AccessInfo;
    [k: string]: any;
}, fieldMatcher?: FieldMatcher, conditionsMatcher?: ConditionsMatcher<MatchConditions>): PureAbility<import("@casl/ability").AbilityTuple, RuleConditions>;
export declare function renderCondition(conditions: Record<string, any>, vars: any): Record<string, any>;
export declare function renderValues<T = any>(object: any, vars: any | ((key: string) => any)): T;
export declare function getValueByPath(obj: any, path: string): any;