## API Report File for "@digitalpersona/core"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

// @public
export class Answer {
    constructor(question: Question | QuestionNumber, text: string);
    readonly number: QuestionNumber;
    readonly text: string;
    readonly version: 1;
}

// @public
export type Answers = Answer[];

// @public
export class Base32 {
    static fromBytes(bytes: Uint8Array | number[]): Base32String;
}

// @public
export type Base32String = string & {
    encoding?: "base32";
};

// @public
export class Base64 {
    static fromBase64Url: (s: Base64UrlString) => Base64String;
    static fromBytes: (bytes: Uint8Array) => Base64String;
    static fromJSON: (obj: string | object) => Base64String;
    static fromUtf16: (s: Utf16String) => Base64String;
    static fromUtf8: (s: Utf8String) => Base64String;
}

// @public
export type Base64String = string & {
    encoding?: "base64";
};

// @public
export class Base64Url {
    static fromBase64: (s: Base64String) => Base64UrlString;
    static fromBytes: (bytes: Uint8Array) => Base64UrlString;
    static fromJSON: (obj: string | object) => Base64UrlString;
    static fromUtf16: (s: Utf16String) => Base64UrlString;
    static fromUtf8: (s: Utf8String) => Base64UrlString;
}

// @public
export type Base64UrlString = string & {
    encoding?: "base64url";
};

// @public
export enum BioFactor {
    // (undocumented)
    FacialFeatures = 2,
    // (undocumented)
    Fingerprint = 8,
    // (undocumented)
    Gait = 4096,
    // (undocumented)
    HandGeometry = 64,
    // (undocumented)
    Iris = 16,
    // (undocumented)
    KeystrokeDynamics = 256,
    // (undocumented)
    LipMovement = 512,
    // (undocumented)
    Multiple = 1,
    // (undocumented)
    Retina = 32,
    // (undocumented)
    SignatureDynamics = 128,
    // (undocumented)
    ThermalFaceImage = 1024,
    // (undocumented)
    ThermalHandImage = 2048,
    // (undocumented)
    Voice = 4
}

// @public
export class BioSample {
    constructor(
    Header: BioSampleHeader, 
    Data: Base64UrlString);
    readonly Data: Base64UrlString;
    readonly Header: BioSampleHeader;
    readonly Version = 1;
}

// @public
export enum BioSampleEncryption {
    // (undocumented)
    None = 0,
    // (undocumented)
    XTEA = 1
}

// @public
export class BioSampleFormat {
    constructor(FormatOwner: BioSampleFormatOwner, FormatID: number);
    // (undocumented)
    readonly FormatID: number;
    // (undocumented)
    readonly FormatOwner: BioSampleFormatOwner;
}

// @public
export enum BioSampleFormatOwner {
    Cognitec = 99,
    DigitalPersona = 51,
    Innovatrics = 53,
    Neurotechnologija = 49,
    // (undocumented)
    None = 0
}

// @public
export class BioSampleHeader {
    constructor(
    Factor: BioFactor, 
    Format: BioSampleFormat, 
    Type: BioSampleType, 
    Purpose: BioSamplePurpose, 
    Quality: number, 
    Encryption: BioSampleEncryption);
    Encryption: BioSampleEncryption;
    Factor: BioFactor;
    Format: BioSampleFormat;
    Purpose: BioSamplePurpose;
    Quality: number;
    Type: BioSampleType;
}

// @public
export enum BioSamplePurpose {
    // (undocumented)
    Any = 0,
    // (undocumented)
    Audit = 6,
    // (undocumented)
    Enroll = 3,
    // (undocumented)
    EnrollForIdentificationOnly = 5,
    // (undocumented)
    EnrollForVerificationOnly = 4,
    // (undocumented)
    Identify = 2,
    // (undocumented)
    Verify = 1
}

// @public
export enum BioSampleType {
    // (undocumented)
    Encrypted = 16,
    // (undocumented)
    Intermediate = 2,
    // (undocumented)
    Processed = 4,
    // (undocumented)
    Raw = 1,
    // (undocumented)
    RawWSQCompressed = 8,
    // (undocumented)
    Signed = 32
}

// @public
export enum ClaimName {
    // (undocumented)
    ADGuid = "ad_guid",
    // (undocumented)
    Audience = "aud",
    // (undocumented)
    CredentialsUsed = "crd",
    // (undocumented)
    ExpiresAfter = "exp",
    // (undocumented)
    Group = "group",
    // (undocumented)
    IssuedAt = "iat",
    // (undocumented)
    IssuerDomain = "dom",
    // (undocumented)
    IssuerName = "iss",
    // (undocumented)
    NotBefore = "nbf",
    // (undocumented)
    Role = "role",
    // (undocumented)
    SubjectName = "sub",
    // (undocumented)
    SubjectUid = "uid",
    // (undocumented)
    T24Principal = "t24",
    // (undocumented)
    TokensId = "jti",
    // (undocumented)
    WindowsAccountName = "wan"
}

// @public
export type ClaimNames = {
    [K in keyof ClaimSet]: ClaimSet[K] extends Function ? never : K;
}[keyof ClaimSet];

// @public
export interface ClaimSet {
    readonly aud?: string;
    readonly crd?: CredentialUsed[];
    readonly dom?: string;
    readonly exp?: number;
    readonly group?: string[];
    readonly iat?: number;
    readonly iss?: string;
    // (undocumented)
    readonly jti?: string;
    readonly nbf?: number;
    readonly role?: string[];
    readonly sub?: string | User;
    readonly t24?: string;
    readonly uid?: string;
    readonly wan?: string;
}

// @public
export class Credential {
    constructor(id: CredentialId, data?: string | object | null, encode?: boolean);
    static Any(): Credential;
    // (undocumented)
    static readonly Behavior: CredentialId;
    // (undocumented)
    static readonly Bluetooth: CredentialId;
    // (undocumented)
    static readonly Cards: CredentialId;
    // (undocumented)
    static readonly ContactlessCard: CredentialId;
    readonly data: Base64String | null;
    // (undocumented)
    static readonly Email: CredentialId;
    // (undocumented)
    static readonly Face: CredentialId;
    // (undocumented)
    static readonly Fingerprints: CredentialId;
    readonly id: CredentialId;
    // (undocumented)
    static readonly IWA: CredentialId;
    static None(): Credential;
    // (undocumented)
    static readonly OneTimePassword: CredentialId;
    // (undocumented)
    static readonly Password: CredentialId;
    // (undocumented)
    static readonly PIN: CredentialId;
    // (undocumented)
    static readonly ProximityCard: CredentialId;
    // (undocumented)
    static readonly SecurityQuestions: CredentialId;
    // (undocumented)
    static readonly SmartCard: CredentialId;
    // (undocumented)
    static readonly U2F: CredentialId;
}

// @public
export type CredentialId = string & {
    brand?: "dp.core.Credential";
    encoding?: "guid";
};

// @public
export interface CredentialUsed {
    readonly id: CredentialId;
    readonly time: number;
}

// @public
export class FaceImage {
    constructor(
    ImageData: Base64UrlString, 
    ImageType?: FaceImageType);
    static fromCanvas(canvas: HTMLCanvasElement, quality?: number): FaceImage;
    static fromDataURL(image: Base64String): FaceImage;
    readonly ImageData: Base64UrlString;
    readonly ImageType: FaceImageType;
    toBioSample(format?: BioSampleFormat, purpose?: BioSamplePurpose, sdkVersion?: number): BioSample;
    readonly Version = 1;
}

// @public
export enum FaceImageType {
    // (undocumented)
    Jpeg = 1
}

// @public
export class Finger {
    constructor(
    position: FingerPosition);
    static fromJson(json: object): Finger;
    readonly position: FingerPosition;
}

// @public
export enum FingerPosition {
    // (undocumented)
    LeftIndex = 7,
    // (undocumented)
    LeftLittle = 10,
    // (undocumented)
    LeftMiddle = 8,
    // (undocumented)
    LeftRing = 9,
    // (undocumented)
    LeftThumb = 6,
    // (undocumented)
    RightIndex = 2,
    // (undocumented)
    RightLittle = 5,
    // (undocumented)
    RightMiddle = 3,
    // (undocumented)
    RightRing = 4,
    // (undocumented)
    RightThumb = 1,
    // (undocumented)
    Unknown = 0
}

// @public
export type Fingers = Finger[];

// @public
export type HexString = string & {
    encoding?: "hex";
};

// @public
export type JSONWebToken = string & {
    encoding?: "jwt";
};

// @public
export class JWT {
    static claims(jwt: JSONWebToken): ClaimSet;
    static errors(jwt: JSONWebToken): Error[] | null;
}

// @public
export class Question {
    constructor(
    number: QuestionNumber, 
    lang_id: number, 
    sublang_id: number, 
    keyboard_layout: number, 
    text?: string | undefined);
    static fromJson(json: object): Question;
    readonly keyboard_layout: number;
    readonly lang_id: number;
    readonly number: QuestionNumber;
    readonly sublang_id: number;
    readonly text?: string | undefined;
    readonly type: QuestionType;
    readonly version = 1;
}

// @public (undocumented)
export type QuestionNumber = number & {
    brand?: "dp.core.Question";
    min?: 0;
    max?: 103;
};

// @public
export type Questions = Question[];

// @public
export enum QuestionType {
    Custom = 1,
    Regular = 0
}

// @public
export interface QuestionWithAnswer {
    // (undocumented)
    answer: Answer;
    // (undocumented)
    question: Question;
}

// @public
export class Ticket {
    constructor(jwt: JSONWebToken);
    readonly jwt: JSONWebToken;
    static None(): Ticket;
}

// @public
export class Url {
    constructor(base: string, path?: string | null, query?: object | null);
    static create(base: string, path?: string | null, query?: object | null): string;
    readonly href: string;
}

// @public
export class User {
    constructor(name: string, type?: UserNameType);
    static Anonymous(): User;
    static Everyone(): User;
    static fromJWT(token: JSONWebToken, type?: UserNameType): User;
    // (undocumented)
    isAnonymous(): boolean;
    // (undocumented)
    isEveryone(): boolean;
    readonly name: string;
    readonly type: UserNameType;
}

// @public
export enum UserNameType {
    Display = 7,
    DNSDomain = 2,
    DP = 9,
    NetBIOSDomain = 1,
    SAM = 3,
    SID = 8,
    Simple = 4,
    UID = 5,
    Unknown = 0,
    UPN = 6
}

// @public
export class Utf16 {
    static fromBase64: (s: Base64String) => Utf16String;
    static fromBase64Url: (s: Base64UrlString) => Utf16String;
    static fromUtf8: (s: Utf8String) => Utf16String;
    static noBom: (s: Utf16String) => Utf16String;
    static withBom: (s: Utf16String) => Utf16String;
}

// @public
export type Utf16String = string & {
    encoding?: "utf16";
};

// @public
export class Utf8 {
    static fromBase64: (s: Base64String) => Utf8String;
    static fromBase64Url: (s: Base64UrlString) => Utf8String;
    static fromBytes: (bytes: number[] | Uint8Array) => Utf8String;
    static fromUtf16: (s: Utf16String) => Utf8String;
    static noBom: (s: Utf8String) => Utf8String;
    static withBom: (s: Utf8String) => Utf8String;
}

// @public
export type Utf8String = string & {
    encoding?: "utf8";
};


// (No @packageDocumentation comment for this package)

```