agentic-flow 2.0.1-alpha.9 → 2.0.2-alpha

package/packages/agentic-jujutsu/index.d.ts

@@ -0,0 +1,853 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/** Configuration for JJWrapper */
+export interface JjConfig {
+  /** Path to jj executable (default: "jj") */
+  jjPath: string
+  /** Repository path (default: current directory) */
+  repoPath: string
+  /** Timeout for operations in milliseconds */
+  timeoutMs: number
+  /** Enable verbose logging */
+  verbose: boolean
+  /** Maximum operation log entries to keep in memory */
+  maxLogEntries: number
+  /** Enable AgentDB sync */
+  enableAgentdbSync: boolean
+}
+/**
+ * ML-DSA signing keypair
+ *
+ * Contains public and secret keys for quantum-resistant digital signatures.
+ */
+export interface SigningKeypair {
+  /** Public key (hex-encoded) */
+  publicKey: string
+  /** Secret key (hex-encoded) - should be kept secure */
+  secretKey: string
+}
+/**
+ * Digital signature for an operation
+ *
+ * Contains the signature and associated metadata.
+ */
+export interface OperationSignature {
+  /** Signature bytes (hex-encoded) */
+  signature: string
+  /** Public key used for verification (hex-encoded) */
+  publicKey: string
+  /** Timestamp when signature was created (ISO 8601) */
+  signedAt: string
+  /** Algorithm identifier */
+  algorithm: string
+}
+/**
+ * Generate a new ML-DSA signing keypair
+ *
+ * Creates a quantum-resistant keypair for signing operations.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::crypto::generate_signing_keypair;
+ *
+ * let keypair = generate_signing_keypair();
+ * println!("Public key: {}", keypair.public_key);
+ * ```
+ */
+export declare function generateSigningKeypair(): SigningKeypair
+/**
+ * Sign a message with ML-DSA
+ *
+ * Creates a quantum-resistant digital signature for the given message.
+ *
+ * # Arguments
+ *
+ * * `message` - The message to sign
+ * * `secret_key` - The secret key in hex format
+ *
+ * # Returns
+ *
+ * The signature bytes in hex format
+ */
+export declare function signMessage(message: Array<number>, secretKey: string): string
+/**
+ * Verify a message signature with ML-DSA
+ *
+ * Verifies that a signature is valid for the given message and public key.
+ *
+ * # Arguments
+ *
+ * * `message` - The message that was signed
+ * * `signature` - The signature in hex format
+ * * `public_key` - The public key in hex format
+ *
+ * # Returns
+ *
+ * `true` if the signature is valid, `false` otherwise
+ */
+export declare function verifySignature(message: Array<number>, signature: string, publicKey: string): boolean
+/**
+ * Type of jujutsu operation
+ *
+ * Represents the various operations that can be performed in a jujutsu repository.
+ */
+export const enum OperationType {
+  /** Create a new commit */
+  Commit = 0,
+  /** Snapshot operation (automatic) */
+  Snapshot = 1,
+  /** Describe/amend commit message */
+  Describe = 2,
+  /** New commit creation */
+  New = 3,
+  /** Edit commit */
+  Edit = 4,
+  /** Abandon a commit */
+  Abandon = 5,
+  /** Rebase commits */
+  Rebase = 6,
+  /** Squash commits */
+  Squash = 7,
+  /** Resolve conflicts */
+  Resolve = 8,
+  /** Branch operation */
+  Branch = 9,
+  /** Delete a branch */
+  BranchDelete = 10,
+  /** Bookmark operation */
+  Bookmark = 11,
+  /** Create a tag */
+  Tag = 12,
+  /** Checkout a commit */
+  Checkout = 13,
+  /** Restore files */
+  Restore = 14,
+  /** Split a commit */
+  Split = 15,
+  /** Duplicate a commit */
+  Duplicate = 16,
+  /** Undo last operation */
+  Undo = 17,
+  /** Fetch from remote */
+  Fetch = 18,
+  /** Git fetch */
+  GitFetch = 19,
+  /** Push to remote */
+  Push = 20,
+  /** Git push */
+  GitPush = 21,
+  /** Clone repository */
+  Clone = 22,
+  /** Initialize repository */
+  Init = 23,
+  /** Git import */
+  GitImport = 24,
+  /** Git export */
+  GitExport = 25,
+  /** Move changes */
+  Move = 26,
+  /** Diffedit */
+  Diffedit = 27,
+  /** Merge branches */
+  Merge = 28,
+  /** Show status */
+  Status = 29,
+  /** Show commit log */
+  Log = 30,
+  /** Show diff */
+  Diff = 31,
+  /** Unknown operation type */
+  Unknown = 32
+}
+/**
+ * Single jujutsu operation
+ *
+ * Represents a single operation in the jujutsu operation log with metadata.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::operations::{JJOperation, OperationType};
+ *
+ * let op = JJOperation::builder()
+ *     .operation_type(OperationType::Commit)
+ *     .command("jj commit".to_string())
+ *     .user("alice".to_string())
+ *     .build();
+ * ```
+ */
+export interface JjOperation {
+  /** Unique operation ID (generated by wrapper) */
+  id: string
+  /** Operation ID from jj (e.g., "abc123@example.com") */
+  operationId: string
+  /** Operation type (as string for N-API compatibility) */
+  operationType: string
+  /** Command that created this operation */
+  command: string
+  /** User who performed the operation */
+  user: string
+  /** Hostname where operation was performed */
+  hostname: string
+  /** Operation timestamp (ISO 8601 format) */
+  timestamp: string
+  /** Tags associated with this operation */
+  tags: Array<string>
+  /** Additional metadata (JSON string for N-API compatibility) */
+  metadata: string
+  /** Parent operation ID */
+  parentId?: string
+  /** Duration in milliseconds */
+  durationMs: number
+  /** Whether this operation was successful */
+  success: boolean
+  /** Error message (if failed) */
+  error?: string
+  /** Quantum fingerprint for fast integrity verification (hex string) */
+  quantumFingerprint?: string
+  /** Digital signature (hex-encoded, optional) */
+  signature?: string
+  /** Public key used for signature verification (hex-encoded, optional) */
+  signaturePublicKey?: string
+}
+/**
+ * Quantum-resistant signing keypair (ML-DSA-65)
+ *
+ * This structure holds both the public and secret keys for ML-DSA signing.
+ * Keys are stored as base64-encoded strings for JSON serialization.
+ *
+ * # Security Notes
+ *
+ * - Secret keys should be stored securely (encrypted at rest)
+ * - Use key rotation policies (recommend rotation every 90 days)
+ * - Never commit secret keys to version control
+ * - Consider hardware security modules (HSM) for production
+ */
+export interface SigningKeypair {
+  /** Base64-encoded ML-DSA-65 public key (~1,952 bytes) */
+  publicKey: string
+  /**
+   * Base64-encoded ML-DSA-65 secret key (~4,032 bytes)
+   * SECURITY: Handle with extreme care
+   */
+  secretKey: string
+  /** Key generation timestamp (ISO 8601) */
+  createdAt: string
+  /** Key identifier (SHA-256 hash of public key, first 16 chars) */
+  keyId: string
+  /** Algorithm identifier */
+  algorithm: string
+}
+/**
+ * Quantum-resistant commit signature
+ *
+ * This structure represents a signed commit with ML-DSA signature and metadata.
+ *
+ * # Verification
+ *
+ * To verify a signature:
+ * 1. Reconstruct commit data from commit_id and metadata
+ * 2. Verify signature using public key
+ * 3. Check timestamp is reasonable (not too old/future)
+ */
+export interface CommitSignature {
+  /** Commit ID that was signed */
+  commitId: string
+  /** Base64-encoded ML-DSA-65 signature (~3,309 bytes) */
+  signature: string
+  /** Key ID used for signing (references SigningKeypair.key_id) */
+  keyId: string
+  /** Signature timestamp (ISO 8601) */
+  signedAt: string
+  /** Algorithm identifier */
+  algorithm: string
+  /** Additional metadata signed with commit */
+  metadata: Record<string, string>
+}
+/**
+ * Result wrapper for jujutsu operations
+ *
+ * This type extends the basic command result with metadata about execution,
+ * warnings, and structured data.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::types::JJResult;
+ *
+ * let result = JJResult::new("output".to_string(), "".to_string(), 0, 100);
+ * assert!(result.success());
+ * ```
+ */
+export interface JjResult {
+  /** Standard output from the command */
+  stdout: string
+  /** Standard error from the command */
+  stderr: string
+  /** Exit code */
+  exitCode: number
+  /** Command execution time in milliseconds */
+  executionTimeMs: number
+}
+/**
+ * Commit metadata
+ *
+ * Represents a single commit in the jujutsu repository with all associated metadata.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::types::JJCommit;
+ *
+ * let commit = JJCommit::builder()
+ *     .id("abc123".to_string())
+ *     .message("Add new feature".to_string())
+ *     .author("Bob".to_string())
+ *     .build();
+ *
+ * assert_eq!(commit.message, "Add new feature");
+ * ```
+ */
+export interface JjCommit {
+  /** Commit ID (revision hash) */
+  id: string
+  /** Change ID (unique identifier for the change) */
+  changeId: string
+  /** Commit message */
+  message: string
+  /** Author name */
+  author: string
+  /** Author email */
+  authorEmail: string
+  /** Timestamp (ISO 8601 format) */
+  timestamp: string
+  /** Parent commit IDs */
+  parents: Array<string>
+  /** Child commit IDs */
+  children: Array<string>
+  /** Branches pointing to this commit */
+  branches: Array<string>
+  /** Tags associated with this commit */
+  tags: Array<string>
+  /** Whether this is a merge commit */
+  isMerge: boolean
+  /** Whether this commit has conflicts */
+  hasConflicts: boolean
+  /** Whether this is an empty commit */
+  isEmpty: boolean
+}
+/**
+ * Branch information
+ *
+ * Represents a branch in the jujutsu repository.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::types::JJBranch;
+ *
+ * let branch = JJBranch::new("feature/new-api".to_string(), "def456".to_string(), false);
+ * assert_eq!(branch.name, "feature/new-api");
+ * ```
+ */
+export interface JjBranch {
+  /** Branch name */
+  name: string
+  /** Commit ID this branch points to */
+  target: string
+  /** Whether this is a remote branch */
+  isRemote: boolean
+  /** Remote name (if remote branch) */
+  remote?: string
+  /** Whether this branch is tracking a remote */
+  isTracking: boolean
+  /** Whether this is the current branch */
+  isCurrent: boolean
+  /** Creation timestamp (ISO 8601 format) */
+  createdAt: string
+}
+/**
+ * Conflict representation
+ *
+ * Represents a merge conflict with detailed information about conflicting sides.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::types::JJConflict;
+ *
+ * let conflict = JJConflict::builder()
+ *     .path("src/main.rs".to_string())
+ *     .num_conflicts(1)
+ *     .conflict_type("content".to_string())
+ *     .build();
+ * ```
+ */
+export interface JjConflict {
+  /** Unique conflict identifier */
+  id: string
+  /** Path to the conflicted file */
+  path: string
+  /** Number of conflict markers */
+  numConflicts: number
+  /** Sides involved in the conflict */
+  sides: Array<string>
+  /** Conflict type (e.g., "content", "modify/delete") */
+  conflictType: string
+  /** Whether conflict is binary (non-text) */
+  isBinary: boolean
+  /** Whether conflict is resolved */
+  isResolved: boolean
+  /** Resolution strategy used (if resolved) */
+  resolutionStrategy?: string
+}
+/** Represents a diff between two commits */
+export interface JjDiff {
+  /** Files added */
+  added: Array<string>
+  /** Files modified */
+  modified: Array<string>
+  /** Files deleted */
+  deleted: Array<string>
+  /** Files renamed (serialized as "old_path:new_path") */
+  renamed: Array<string>
+  /** Total number of additions */
+  additions: number
+  /** Total number of deletions */
+  deletions: number
+  /** Diff content (unified diff format) */
+  content: string
+}
+/**
+ * Working copy change
+ *
+ * Represents a change in the working copy that hasn't been committed yet.
+ *
+ * # Examples
+ *
+ * ```rust
+ * use agentic_jujutsu::types::{JJChange, ChangeStatus};
+ *
+ * let change = JJChange::new("src/main.rs".to_string());
+ * ```
+ */
+export interface JjChange {
+  /** File path */
+  filePath: string
+  /** Change status */
+  status: ChangeStatus
+  /** Whether file is staged */
+  isStaged: boolean
+  /** Size in bytes (if applicable) - using f64 for N-API compatibility with large numbers */
+  sizeBytes?: number
+}
+/** Status of a file change */
+export const enum ChangeStatus {
+  /** File added */
+  Added = 'Added',
+  /** File modified */
+  Modified = 'Modified',
+  /** File deleted */
+  Deleted = 'Deleted',
+  /** File renamed (old path stored separately in JJChange) */
+  Renamed = 'Renamed',
+  /** File conflicted */
+  Conflicted = 'Conflicted',
+  /** File type changed */
+  TypeChanged = 'TypeChanged'
+}
+/**
+ * Main quantum signing interface
+ *
+ * Provides methods for generating keypairs, signing commits, and verifying signatures
+ * using ML-DSA-65 post-quantum cryptography.
+ */
+export declare class QuantumSigner {
+  /**
+   * Generate a new ML-DSA-65 signing keypair
+   *
+   * This uses the @qudag/napi-core library to generate quantum-resistant keys.
+   *
+   * # Performance
+   *
+   * - Average: ~2.1ms
+   * - Uses secure random number generation
+   *
+   * # Returns
+   *
+   * A new `SigningKeypair` with ML-DSA-65 keys
+   *
+   * # Examples
+   *
+   * ```javascript
+   * const { QuantumSigner } = require('agentic-jujutsu');
+   * const keypair = QuantumSigner.generateKeypair();
+   * console.log('Key ID:', keypair.keyId);
+   * ```
+   */
+  static generateKeypair(): SigningKeypair
+  /**
+   * Sign a commit with ML-DSA-65 quantum-resistant signature
+   *
+   * Creates a cryptographic signature over the commit ID and optional metadata.
+   * The signature is tamper-proof and quantum-resistant.
+   *
+   * # Parameters
+   *
+   * - `commit_id`: The Jujutsu commit ID to sign
+   * - `secret_key`: Base64-encoded ML-DSA-65 secret key
+   * - `metadata`: Optional additional data to include in signature
+   *
+   * # Returns
+   *
+   * A `CommitSignature` containing the signature and metadata
+   *
+   * # Performance
+   *
+   * - Average: ~1.3ms per signature
+   *
+   * # Security
+   *
+   * - Uses deterministic signing (same input = same signature)
+   * - Includes timestamp to prevent replay attacks
+   * - Binds metadata to signature
+   *
+   * # Examples
+   *
+   * ```javascript
+   * const signature = QuantumSigner.signCommit(
+   *   'abc123',
+   *   keypair.secretKey,
+   *   { author: 'alice', repo: 'my-project' }
+   * );
+   * ```
+   */
+  static signCommit(commitId: string, secretKey: string, metadata?: Record<string, string> | undefined | null): CommitSignature
+  /**
+   * Verify a commit signature using ML-DSA-65
+   *
+   * Verifies that a signature is valid for the given commit and public key.
+   * Returns true if the signature is cryptographically valid and the commit
+   * has not been tampered with.
+   *
+   * # Parameters
+   *
+   * - `commit_id`: The commit ID that was signed
+   * - `signature_data`: The `CommitSignature` to verify
+   * - `public_key`: Base64-encoded ML-DSA-65 public key
+   *
+   * # Returns
+   *
+   * - `true`: Signature is valid
+   * - `false`: Signature is invalid or commit was tampered
+   *
+   * # Performance
+   *
+   * - Average: ~0.85ms per verification
+   *
+   * # Examples
+   *
+   * ```javascript
+   * const isValid = QuantumSigner.verifyCommit(
+   *   'abc123',
+   *   signature,
+   *   keypair.publicKey
+   * );
+   * if (!isValid) {
+   *   throw new Error('Commit signature verification failed!');
+   * }
+   * ```
+   */
+  static verifyCommit(commitId: string, signatureData: CommitSignature, publicKey: string): boolean
+  /**
+   * Export a public key in PEM format
+   *
+   * Converts a base64-encoded public key to PEM format for compatibility
+   * with other tools and systems.
+   *
+   * # Parameters
+   *
+   * - `public_key`: Base64-encoded ML-DSA-65 public key
+   *
+   * # Returns
+   *
+   * PEM-encoded public key string
+   */
+  static exportPublicKeyPem(publicKey: string): string
+  /**
+   * Import a public key from PEM format
+   *
+   * Parses a PEM-encoded ML-DSA-65 public key into base64 format.
+   *
+   * # Parameters
+   *
+   * - `pem`: PEM-encoded public key
+   *
+   * # Returns
+   *
+   * Base64-encoded public key
+   */
+  static importPublicKeyPem(pem: string): string
+  /**
+   * Get signature statistics
+   *
+   * Returns information about ML-DSA-65 algorithm characteristics.
+   *
+   * # Returns
+   *
+   * JSON string with algorithm statistics
+   */
+  static getAlgorithmInfo(): string
+}
+export type JJWrapper = JjWrapper
+/** Main wrapper for Jujutsu operations */
+export declare class JjWrapper {
+  /** Create a new JJWrapper with default configuration */
+  constructor()
+  /** Create a new JJWrapper with custom configuration */
+  static withConfig(config: JjConfig): JjWrapper
+  /** Get the current configuration */
+  getConfig(): JjConfig
+  /** Get operation log statistics as JSON string */
+  getStats(): string
+  /** Execute a jj command and return the result */
+  execute(args: Array<string>): Promise<JjResult>
+  /** Get operations from the operation log */
+  getOperations(limit: number): Array<JjOperation>
+  /** Get user-initiated operations (exclude snapshots) */
+  getUserOperations(limit: number): Array<JjOperation>
+  /** Get conflicts in the current commit or specified commit */
+  getConflicts(commit?: string | undefined | null): Promise<Array<JjConflict>>
+  /** Describe the current commit with a message */
+  describe(message: string): Promise<JjOperation>
+  /** Get repository status */
+  status(): Promise<JjResult>
+  /** Get diff between two commits */
+  diff(from: string, to: string): Promise<JjDiff>
+  /** Create a new commit (renamed from 'new' to avoid confusion with constructor) */
+  newCommit(message?: string | undefined | null): Promise<JjResult>
+  /** Edit a commit */
+  edit(revision: string): Promise<JjResult>
+  /** Abandon a commit */
+  abandon(revision: string): Promise<JjResult>
+  /** Squash commits */
+  squash(from?: string | undefined | null, to?: string | undefined | null): Promise<JjResult>
+  /** Rebase commits */
+  rebase(source: string, destination: string): Promise<JjResult>
+  /** Resolve conflicts */
+  resolve(path?: string | undefined | null): Promise<JjResult>
+  /** Create a branch */
+  branchCreate(name: string, revision?: string | undefined | null): Promise<JjResult>
+  /** Delete a branch */
+  branchDelete(name: string): Promise<JjResult>
+  /** List branches */
+  branchList(): Promise<Array<JjBranch>>
+  /** Undo the last operation */
+  undo(): Promise<JjResult>
+  /** Restore files */
+  restore(paths: Array<string>): Promise<JjResult>
+  /** Show commit log */
+  log(limit?: number | undefined | null): Promise<Array<JjCommit>>
+  /** Clear operation log */
+  clearLog(): void
+  /** Start a learning trajectory for a task */
+  startTrajectory(task: string): string
+  /** Add current operations to the active trajectory */
+  addToTrajectory(): void
+  /** Finalize trajectory with success score and store it */
+  finalizeTrajectory(successScore: number, critique?: string | undefined | null): void
+  /** Get decision suggestion from reasoning bank */
+  getSuggestion(task: string): string
+  /** Get learning statistics from reasoning bank */
+  getLearningStats(): string
+  /** Get all discovered patterns */
+  getPatterns(): string
+  /**
+   * Enable quantum-resistant encryption for ReasoningBank trajectory storage
+   *
+   * Uses HQC-128 encryption from @qudag/napi-core for quantum-resistant security
+   *
+   * # Arguments
+   * * `encryption_key` - Base64-encoded encryption key (32 bytes)
+   * * `public_key` - Optional base64-encoded public key for HQC
+   *
+   * # Example
+   * ```javascript
+   * const crypto = require('crypto');
+   * const encryptionKey = crypto.randomBytes(32).toString('base64');
+   * await wrapper.enableEncryption(encryptionKey);
+   * ```
+   */
+  enableEncryption(encryptionKey: string, publicKey?: string | undefined | null): void
+  /** Disable encryption for ReasoningBank */
+  disableEncryption(): void
+  /** Check if encryption is enabled */
+  isEncryptionEnabled(): boolean
+  /**
+   * Decrypt a trajectory by ID
+   *
+   * # Arguments
+   * * `trajectory_id` - UUID of the trajectory to decrypt
+   * * `decrypted_payload` - Decrypted JSON payload from HQC decryption
+   *
+   * # Returns
+   * JSON string of the decrypted trajectory
+   */
+  decryptTrajectory(trajectoryId: string, decryptedPayload: string): string
+  /**
+   * Get encrypted payload for a trajectory (for HQC encryption in JavaScript)
+   *
+   * Returns the plaintext payload that should be encrypted with HQC
+   */
+  getTrajectoryPayload(trajectoryId: string): string | null
+  /** Query similar trajectories by task */
+  queryTrajectories(task: string, limit: number): string
+  /** Reset reasoning bank (clear all learning) */
+  resetLearning(): void
+  /** Enable agent coordination with QuantumDAG */
+  enableAgentCoordination(): Promise<void>
+  /** Register a new agent in the coordination system */
+  registerAgent(agentId: string, agentType: string): Promise<void>
+  /** Register an agent operation in the coordination system */
+  registerAgentOperation(agentId: string, operationId: string, affectedFiles: Array<string>): Promise<string>
+  /** Check for conflicts with proposed operation */
+  checkAgentConflicts(operationId: string, operationType: string, affectedFiles: Array<string>): Promise<string>
+  /** Get agent statistics */
+  getAgentStats(agentId: string): Promise<string>
+  /** List all registered agents */
+  listAgents(): Promise<string>
+  /** Get coordination statistics */
+  getCoordinationStats(): Promise<string>
+  /** Get coordination tips (DAG tips) */
+  getCoordinationTips(): Promise<Array<string>>
+  /**
+   * Generate a quantum fingerprint for an operation
+   *
+   * This method generates a quantum-resistant fingerprint using @qudag/napi-core
+   * for fast integrity verification of JJ operations.
+   *
+   * # Arguments
+   * * `operation_id` - The ID of the operation to fingerprint
+   *
+   * # Returns
+   * The quantum fingerprint as a hex string
+   *
+   * # Example
+   * ```javascript
+   * const wrapper = new JJWrapper();
+   * const fingerprint = await wrapper.generateOperationFingerprint(operationId);
+   * ```
+   */
+  generateOperationFingerprint(operationId: string): Promise<string>
+  /**
+   * Verify an operation's quantum fingerprint
+   *
+   * Checks if the stored quantum fingerprint matches the current operation data.
+   *
+   * # Arguments
+   * * `operation_id` - The ID of the operation to verify
+   * * `fingerprint` - The expected fingerprint to verify against
+   *
+   * # Returns
+   * `true` if the fingerprint is valid, `false` otherwise
+   *
+   * # Example
+   * ```javascript
+   * const isValid = await wrapper.verifyOperationFingerprint(operationId, fingerprint);
+   * if (isValid) {
+   *   console.log('Operation integrity verified!');
+   * }
+   * ```
+   */
+  verifyOperationFingerprint(operationId: string, fingerprint: string): Promise<boolean>
+  /**
+   * Get operation data for quantum fingerprint generation (helper method)
+   *
+   * Returns the serialized operation data that should be fingerprinted.
+   * This is used by the JavaScript wrapper to call @qudag/napi-core.
+   *
+   * # Arguments
+   * * `operation_id` - The ID of the operation
+   *
+   * # Returns
+   * The operation data as a Buffer (Uint8Array in JS)
+   */
+  getOperationData(operationId: string): Array<number>
+  /**
+   * Update operation with quantum fingerprint
+   *
+   * Stores a quantum fingerprint for an operation.
+   *
+   * # Arguments
+   * * `operation_id` - The ID of the operation
+   * * `fingerprint` - The quantum fingerprint (hex string)
+   */
+  setOperationFingerprint(operationId: string, fingerprint: string): void
+  /**
+   * Sign an operation by ID
+   *
+   * Creates a quantum-resistant digital signature for the specified operation.
+   *
+   * # Arguments
+   *
+   * * `operation_id` - The operation ID to sign
+   * * `secret_key` - The secret key in hex format
+   * * `public_key` - The corresponding public key in hex format
+   */
+  signOperation(operationId: string, secretKey: string, publicKey: string): void
+  /**
+   * Verify an operation's signature by ID
+   *
+   * # Arguments
+   *
+   * * `operation_id` - The operation ID to verify
+   *
+   * # Returns
+   *
+   * `true` if signature is valid, `false` if invalid
+   */
+  verifyOperationSignature(operationId: string): boolean
+  /**
+   * Verify all operations in the log
+   *
+   * # Arguments
+   *
+   * * `public_key` - Optional public key to verify against
+   *
+   * # Returns
+   *
+   * JSON string with verification results: { total_signed, valid_count, invalid_count }
+   */
+  verifyAllOperations(publicKey?: string | undefined | null): string
+  /**
+   * Sign all unsigned operations
+   *
+   * # Arguments
+   *
+   * * `secret_key` - The secret key in hex format
+   * * `public_key` - The corresponding public key in hex format
+   *
+   * # Returns
+   *
+   * Number of operations that were signed
+   */
+  signAllOperations(secretKey: string, publicKey: string): number
+  /** Get count of signed operations */
+  getSignedOperationsCount(): number
+  /** Get count of unsigned operations */
+  getUnsignedOperationsCount(): number
+  /**
+   * Verify signature chain integrity
+   *
+   * Verifies that all signed operations form a valid chain.
+   *
+   * # Returns
+   *
+   * `true` if chain is valid, `false` if broken
+   */
+  verifySignatureChain(): boolean
+}