@synet/identity/dist/identity.d.ts

Simple and secure identity management library for Verifiable Identity

/**
 * @synet/identity - Identity Unit
 *
 * Creates and manages decentralized identities by composing multiple units:
 * - DID unit for decentralized identifier management
 * - Signer unit for cryptographic signing operations
 * - Key unit for public key operations
 * - Credential unit for verifiable credential operations
 *
 * The Identity follows Unit Architecture with props-based construction
 * and teaching/learning contracts for capability sharing.
 *
 *
 * @author Synet Team
 */
import { Signer } from "@synet/keys";
import { DID } from "@synet/did";
import { Credential } from "@synet/credential";
import type { SynetVerifiableCredential, BaseCredentialSubject } from "@synet/credential";
import { Result } from "./result";
import { Unit, type UnitProps, type UnitSchema, type TeachingContract } from "@synet/unit";
export interface IdentityConfig {
    alias: string;
    did: string;
    publicKeyHex: string;
    privateKeyHex: string;
    kid?: string;
    provider?: string;
    credential?: SynetVerifiableCredential<BaseCredentialSubject>;
    metadata?: Record<string, unknown>;
    createdAt?: Date;
}
export interface IdentityProps extends UnitProps {
    dna: UnitSchema;
    alias: string;
    did: string;
    kid: string;
    publicKeyHex: string;
    privateKeyHex?: string;
    provider: string;
    credential: SynetVerifiableCredential<BaseCredentialSubject>;
    metadata: Record<string, unknown>;
    createdAt: Date;
    didUnit: DID;
    signerUnit: Signer;
    keyUnit: ReturnType<Signer["createKey"]>;
    credentialUnit: Credential;
}
export interface IIdentity {
    alias: string;
    did: string;
    kid: string;
    publicKeyHex: string;
    privateKeyHex?: string;
    provider: string;
    credential: SynetVerifiableCredential<BaseCredentialSubject>;
    metadata?: Record<string, unknown>;
    createdAt: Date;
}
export interface IdentityPresent {
    did: string;
    publicKeyHex: string;
    credential: SynetVerifiableCredential<BaseCredentialSubject>;
}
/**
 * Identity Unit - Unit Architecture implementation
 * Composes DID, Signer, Key, and Credential units
 */
export declare class Identity extends Unit<IdentityProps> {
    protected constructor(props: IdentityProps);
    /**
     * Create identity from existing data or config
     */
    static create(config: IdentityConfig): Result<Identity>;
    /**
     * Generate a new identity with fresh cryptographic material
     */
    static generate(alias: string): Promise<Result<Identity>>;
    whoami(): string;
    capabilities(): string[];
    help(): void;
    teach(): TeachingContract;
    /**
     * @depricated, use generate() instead.
    */
    generateIdentity(alias: string): Promise<Result<Identity>>;
    /**
     * Issue and sign Verifable Credential.
     * @param subject
     * @param type
     * @param issuer
     * @returns
     */
    issueCredential(subject: BaseCredentialSubject, type: string, issuer?: string): Promise<Result<SynetVerifiableCredential<BaseCredentialSubject>>>;
    sign(data: string): Promise<string>;
    verify(data: string, signature: string): Promise<boolean>;
    get publicKeyHex(): string;
    get privateKeyHex(): string | undefined;
    get alias(): string;
    get did(): string;
    get credential(): SynetVerifiableCredential<BaseCredentialSubject>;
    get metadata(): Record<string, unknown>;
    /**
    * Get identity provider
    */
    get provider(): string;
    getDid(): string;
    getPublicKey(): string;
    /**
     * @deprecated Use getPublicKey() instead
     */
    getPublicKeyHex(): string;
    didUnit(): DID;
    /**
     * Get Key unit for public key operations
     */
    keyUnit(): ReturnType<Signer["createKey"]>;
    /**
     * Get Signer unit for signing operations
     */
    signerUnit(): Signer;
    /**
     * Get Credential unit for verifiable credential operations
     */
    credentialUnit(): Credential;
    /**
     * Get identity alias
     */
    getAlias(): string;
    /**
     * Get key identifier
     */
    getKid(): string;
    /**
     * Get private key in hex format (if available)
     */
    getPrivateKeyHex(): string | undefined;
    /**
     * Get identity provider
     */
    getProvider(): string;
    /**
     * Get verifiable credential
     */
    getCredential(): SynetVerifiableCredential<BaseCredentialSubject>;
    /**
     * Get metadata
     */
    getMetadata(): Record<string, unknown>;
    /**
     * Get creation date
     */
    getCreatedAt(): Date;
    toJSON(): {
        alias: string;
        did: string;
        kid: string;
        publicKeyHex: string;
        privateKeyHex: string | undefined;
        provider: string;
        credential: SynetVerifiableCredential<BaseCredentialSubject>;
        metadata: Record<string, unknown>;
        createdAt: Date;
    };
    /**
     * Convert Identity props to domain entity IIdentity
     * @returns
     *
     */
    toDomain(): IIdentity;
    /**
     * Export public identity data (no private key)
     */
    public(): Omit<IIdentity, "privateKeyHex">;
    /**
     * Presents identity
     * @returns IdentityPresent { did, publicKeyHex, credential }
     */
    present(): IdentityPresent;
}