@httpc/kit/dist/esm/permissions/index.d.ts

httpc toolbox for building function-based API with minimal code and end-to-end type safety

import Parser from "./Parser";
import * as Token from "./Token";
import Serializer from "./Serializer";
import { PermissionsModel } from "./model";
import { ICache } from "../caching";
export { Token as PermissionToken };
export { Parser as PermissionParser };
export * from "./Parser";
export { Serializer as PermissionSerializer };
export * from "./Serializer";
export * from "./model";
export type TokenClaim = string | readonly string[];
export type AuthClaim = Readonly<{
    token: TokenClaim;
    scope?: TokenClaim;
}>;
export type AssertionClaim = AuthClaim & Readonly<{
    negative?: boolean;
}>;
export type GrantClaim = AuthClaim & Readonly<{
    subject: TokenClaim;
}>;
export declare class InvalidClaim extends Error {
    readonly claim: string;
    constructor(claim: string, message?: string);
}
export declare class AuthorizationBuilder {
    protected _claims: AuthClaim[];
    constructor(extend: Authorization | AuthorizationBuilder | AuthClaim[] | AuthClaim | string);
    constructor();
    add(claim: AuthClaim | AuthClaim[] | AuthorizationBuilder | Authorization | string): this;
    build(): Authorization;
}
export declare class Authorization {
    readonly claims: AuthClaim[];
    constructor(claims: AuthClaim[]);
    protected [Symbol.iterator](): Generator<Readonly<{
        token: TokenClaim;
        scope?: TokenClaim | undefined;
    }>, void, undefined>;
    merge(auth: string | Authorization): Authorization;
    toString(): string;
    static parse(claims: string): Authorization;
}
export declare class AssertionBuilder {
    protected _claims: AssertionClaim[];
    constructor(extend: Assertion | AssertionBuilder | AssertionClaim[] | AssertionClaim | string);
    constructor();
    add(claim: AssertionClaim | AssertionClaim[] | AssertionBuilder | Assertion | string): this;
    build(): Assertion;
}
export declare class Assertion {
    readonly claims: AssertionClaim[];
    constructor(claims: AssertionClaim[]);
    protected [Symbol.iterator](): Generator<AssertionClaim, void, undefined>;
    toString(): string;
    test(auth: Authorization): AssertResult;
    static parse(claims: string): Assertion;
}
type AssertResult = Readonly<{
    success: true;
}> | Readonly<{
    success: false;
    failed: AuthClaim;
}>;
export declare class PermissionsChecker {
    protected _cache?: ICache<[item: any, validated: boolean]>;
    protected _model?: PermissionsModel;
    constructor(options?: {
        model?: PermissionsModel;
        cache?: false | true | ICache;
    });
    can(authorization: string | Authorization, assertion: string | Assertion): boolean;
    test(authorization: string | Authorization, assertion: string | Assertion): AssertResult;
    supports(authorization: string | Authorization): boolean;
    parse(what: "authorization", value: string): Authorization;
    parse(what: "assertion", value: string): Assertion;
    validate(authorization: Authorization): Authorization;
    validate(assertion: Assertion): Assertion;
    validate<T extends Authorization | Assertion>(what: T): T;
    consolidate(authorization: Authorization): Authorization;
    consolidate(assertion: Assertion): Assertion;
    consolidate<T extends Authorization | Assertion>(what: T): T;
    protected _getAuthorization(authorization: string | Authorization): [Authorization, boolean];
    protected _getAssertion(assertion: string | Assertion): [Assertion, boolean];
    protected _getCachedOrCreate<T>(value: string | T, prefix: string, factory: (value: string) => T): [T, boolean];
    protected _getCacheKey(prefix: string, value: string): string;
}