@decaf-ts/for-fabric 0.11.0 → 0.12.1

package/lib/types/contracts/erc20/models.d.ts

@@ -1,114 +0,0 @@
-import { BaseModel } from "@decaf-ts/core";
-import { type ModelArg } from "@decaf-ts/decorator-validation";
-/**
- * @description ERC20 token metadata model
- * @summary Represents an ERC20 token definition within the Fabric ERC20 sample, including name, symbol, decimals, and the owning identity. Used to define the unique token managed by the contract.
- * @param {ModelArg<ERC20Token>} [m] - Optional partial data or another instance to initialize the model
- * @return {void}
- * @class ERC20Token
- * @example
- * const token = new ERC20Token({ name: "MyToken", symbol: "MTK", decimals: 18, owner: "x509::..." });
- * // Persist through a repository: await repo.create(token, ctx)
- * @mermaid
- * sequenceDiagram
- *   participant App
- *   participant Repo
- *   participant Adapter
- *   App->>Repo: create(new ERC20Token({...}), ctx)
- *   Repo->>Adapter: create(table, id=name, record, flags)
- *   Adapter-->>Repo: stored
- *   Repo-->>App: model
- */
-export declare class ERC20Token extends BaseModel {
-    /**
-     * @description Token unique name
-     * @summary Serves as the primary key for the ERC20 token definition; typically a human-readable identifier
-     */
-    name: string;
-    /**
-     * @description Owning identity of the token
-     * @summary X.509 subject or MSP identity string that denotes who owns/controls the token definition
-     */
-    owner: string;
-    /**
-     * @description Token symbol
-     * @summary Short ticker-like symbol used to represent the token (e.g., MTK)
-     */
-    symbol: string;
-    /**
-     * @description Decimal precision for token amounts
-     * @summary Number of digits after the decimal separator used when formatting token balances
-     */
-    decimals: number;
-    constructor(m?: ModelArg<ERC20Wallet>);
-}
-/**
- * @description ERC20 wallet model
- * @summary Represents a holder account for an ERC20 token within the Fabric network, tracking balance and token association.
- * @param {ModelArg<ERC20Wallet>} [m] - Optional partial data or another instance to initialize the model
- * @return {void}
- * @class ERC20Wallet
- * @example
- * const wallet = new ERC20Wallet({ id: "acct1", token: "MyToken", balance: 1000 });
- * // Update balance via repository: await repo.update(wallet, ctx)
- * @mermaid
- * sequenceDiagram
- *   participant App
- *   participant Repo
- *   App->>Repo: read("acct1", ctx)
- *   Repo-->>App: ERC20Wallet
- */
-export declare class ERC20Wallet extends BaseModel {
-    /**
-     * @description Wallet unique identifier
-     * @summary Primary key for the wallet; commonly references an account or identity
-     */
-    id: string;
-    /**
-     * @description Associated token name
-     * @summary References the ERC20Token this wallet holds; maintained as a relationship for cascading updates/deletes
-     */
-    token: string;
-    /**
-     * @description Token balance for this wallet
-     * @summary Current amount of the associated token held by this wallet
-     */
-    balance: number;
-    /**
-     * @description Captive flag or identifier
-     * @summary Optional field used by some flows to mark non-transferable funds or managed custody
-     */
-    captive: string;
-    constructor(m?: ModelArg<ERC20Wallet>);
-}
-/**
- * @description ERC20 allowance model
- * @summary Captures an approval relationship where an owner allows a spender to transfer up to a certain value from the owner's wallet.
- * @param {ModelArg<Allowance>} [m] - Optional partial data or another instance to initialize the model
- * @return {void}
- * @class Allowance
- * @example
- * const allowance = new Allowance({ owner: "acct1", spender: "acct2", value: 50 });
- * @mermaid
- * sequenceDiagram
- *   participant App
- *   App->>App: new Allowance({ owner, spender, value })
- */
-export declare class Allowance extends BaseModel {
-    /**
-     * @description Owner wallet identifier
-     * @summary Wallet that authorizes the allowance
-     */
-    owner: string;
-    /**
-     * @description Spender wallet identifier
-     * @summary Wallet allowed to spend up to the approved value from the owner
-     */
-    spender: string;
-    /**
-     * @description Approved value
-     * @summary Maximum token amount the spender may transfer on behalf of the owner
-     */
-    value: number;
-    constructor(m?: ModelArg<Allowance>);
-}

package/lib/types/contracts/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * @description Contracts submodule for Hyperledger Fabric integration
- * @summary Aggregates chaincode-side building blocks including repositories, sequences, adapters, and ERC20 helpers. This entrypoint re-exports contract-related elements such as {@link FabricContractRepository},, and CRUD/ERC20 utilities for composing Fabric contracts.
- * @namespace contracts
- * @memberOf module:for-fabric
- */
-import "./overrides";
-export * from "./overrides";
-export * from "./auth";
-export * from "./crud";
-export * from "./erc20";
-export * from "./ContractAdapter";
-export * from "./ContractContext";
-export * from "./FabricContractDispatch";
-export * from "./FabricContractPaginator";
-export * from "./FabricContractRepository";
-export * from "./FabricContractRepositoryObservableHandler";
-export * from "./logging";
-export * from "./types";
-export * from "./MigrationContract";

package/lib/types/contracts/logging.d.ts

@@ -1,54 +0,0 @@
-import { LogLevel, LogMeta, MiniLogger, StringLike } from "@decaf-ts/logging";
-import { LoggingConfig } from "@decaf-ts/logging";
-import { Context as Ctx } from "fabric-contract-api";
-/**
- * @description Logger implementation for Fabric chaincode contracts
- * @summary Adapts the standard logging interface to work with Fabric's chaincode context
- *
- * @param {string} context - The logging context name
- * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration
- * @param {Ctx} ctx - The Fabric chaincode context
- *
- * @class ContractLogger
- * @extends {MiniLogger}
- * @example
- * ```typescript
- * // In a Fabric chaincode contract
- * import { ContractLogger } from '@decaf-ts/for-fabric';
- *
- * export class MyContract extends Contract {
- *   @Transaction()
- *   async myFunction(ctx: Context): Promise<void> {
- *     const logger = new ContractLogger('MyContract', { level: 'info' }, ctx);
- *
- *     logger.info('Processing transaction');
- *     logger.debug('Transaction details:', { ... });
- *
- *     // Do something
- *
- *     logger.info('Transaction complete');
- *   }
- * }
- * ```
- */
-export declare class ContractLogger extends MiniLogger {
-    protected sink: {
-        verbose: (msg: string) => void;
-        info: (msg: string) => void;
-        debug: (msg: string) => void;
-        error: (msg: string) => void;
-        trace: (msg: string) => void;
-        warn: (msg: string) => void;
-        silly: (msg: string) => void;
-    };
-    constructor(context: string, conf: Partial<LoggingConfig> | undefined, ctx?: Ctx);
-    /**
-     * @description Logs a message at the specified level
-     * @summary Overrides the base log method to use the Fabric context's logger
-     * @param {LogLevel} level - The log level
-     * @param {StringLike | Error} msg - The message to log
-     * @param {Error} [stack] - Optional stack trace for errors
-     * @return {void}
-     */
-    protected log(level: LogLevel, msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
-}

package/lib/types/contracts/overrides.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/contracts/types.d.ts

@@ -1,38 +0,0 @@
-import { ChaincodeStub, ClientIdentity } from "fabric-shim-api";
-import { Logger } from "@decaf-ts/logging";
-import { FabricFlags } from "../shared/index";
-/**
- * @description Flags for Fabric chaincode contract operations
- * @summary Extends repository flags with Fabric-specific context elements available during Fabric chaincode execution, such as the ChaincodeStub, ClientIdentity and a request-scoped Logger.
- * @template T
- * @param {RepositoryFlags} [base] - Base repository flags that these Fabric-specific flags extend
- * @return {void}
- * @interface FabricContractFlags
- * @memberOf module:fabric.contracts
- */
-export interface FabricContractFlags extends FabricFlags {
-    /**
-     * @description Chaincode stub for interacting with the ledger
-     */
-    stub: ChaincodeStub;
-    /**
-     * @description Client identity for the transaction submitter
-     */
-    identity: ClientIdentity;
-    roles?: string[];
-    cert: string;
-    segregateWrite?: Record<string, string[]>;
-    segregateRead?: string | string[];
-    forceSegregateWrite?: boolean;
-    fullySegregated?: boolean;
-    sequenceSegregation?: Map<string, {
-        fullySegregated: boolean;
-        collections: string[];
-    }>;
-    segregatedData?: Record<string, Record<string, any>>;
-    segregateReadStack?: any[];
-    /**
-     * @description Logger instance for the contract
-     */
-    logger: Logger;
-}

package/lib/types/contracts/uuid.d.ts

@@ -1,2 +0,0 @@
-export declare function bytesToUuidV5Style(bytes16: Uint8Array): string;
-export declare function uuidFromSeed(seed: string): Promise<string>;

package/lib/types/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * @description Hyperledger Fabric Module for Decaf-ts
- * @summary Provides client-side and chaincode-side tooling for building Hyperledger Fabric applications with Decaf-ts. Exposes client adapters, repositories, contract adapters, sequences, utilities, and shared types to streamline development and interaction with Fabric networks. See {@link module:fabric.client}, {@link module:fabric.contracts}, and {@link module:fabric.shared} for grouped exports.
- * @module for-fabric
- */
-export * from "./client";
-export * from "./shared";
-export * from "./version";

package/lib/types/shared/ClientSerializer.d.ts

@@ -1,52 +0,0 @@
-import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
-/**
- * @description Client-side JSON serializer for Decaf models targeting Hyperledger Fabric
- * @summary Extends the base JSONSerializer to embed model metadata (anchor) required to reconstruct instances on the client, and to safely serialize/deserialize Fabric-bound models.
- * @template M extends Model - The Decaf model type handled by this serializer
- * @param {void} [constructor] No public constructor arguments; provided for documentation completeness
- * @return {void}
- * @class ClientSerializer
- * @example
- * const serializer = new ClientSerializer<User>();
- * const json = serializer.serialize(new User({ id: "1", name: "Alice" }));
- * const user = serializer.deserialize(json);
- * @mermaid
- * sequenceDiagram
- *   participant App
- *   participant Serializer as ClientSerializer
- *   participant Model
- *   App->>Serializer: serialize(model)
- *   Serializer->>Serializer: preSerialize(model)
- *   Serializer-->>App: JSON string
- *   App->>Serializer: deserialize(json)
- *   Serializer->>Serializer: JSON.parse(json)
- *   Serializer->>Model: Model.build(parsed, anchor)
- *   Model-->>App: instance
- */
-export declare class ClientSerializer<M extends Model> extends JSONSerializer<M> {
-    constructor();
-    /**
-     * @description Prepare a model for JSON serialization embedding class anchor
-     * @summary Clones the model and injects the class metadata anchor so it can be reconstructed during deserialization. Falls back to provided table name if metadata is not available.
-     * @template M - Model type handled by this serializer
-     * @param {M} model - The model instance to serialize
-     * @param {string} [modelName] - Optional table name to use when metadata cannot be derived
-     * @return {Record<string, any>} A plain object ready to be JSON.stringify'd
-     */
-    protected preSerialize(model: M, modelName?: string): Record<string, any>;
-    /**
-     * @description Rebuilds a model from its JSON serialization
-     * @summary Parses the JSON string, retrieves the embedded model anchor, and uses Model.build to reconstruct the original instance
-     * @param {string} str - The JSON string previously produced by serialize
-     * @return {M} The reconstructed model instance
-     */
-    deserialize(str: string): M;
-    /**
-     * @description Serializes a model to a JSON string
-     * @summary Prepares the model via preSerialize, embedding metadata needed for reconstruction, and returns a JSON string representation
-     * @param {M} model - The model instance to serialize
-     * @param {string} [table] - Optional table name to include as anchor when metadata is unavailable
-     * @return {string} A JSON string containing the serialized model with anchor metadata
-     */
-    serialize(model: M, modelName?: string): string;
-}

package/lib/types/shared/DeterministicSerializer.d.ts

@@ -1,47 +0,0 @@
-import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
-/**
- * @description Recursively sorts object keys without reordering arrays
- * @param {any} obj - The value to process
- * @return {any} A copy with sorted object keys but preserved array order
- */
-export declare function sortKeysOnlyRecursive(obj: any): any;
-/**
- * @description Deterministic JSON serializer for Fabric models
- * @summary Ensures stable, deterministic JSON output by sorting object keys recursively before stringification, which is important for Fabric endorsement and hashing. Extends JSONSerializer to plug into existing Decaf model serialization flow.
- * @template M - The Decaf Model subtype serialized by this instance
- * @param {void} [constructor] No public constructor arguments
- * @class DeterministicSerializer
- * @example
- * const serializer = new DeterministicSerializer<MyModel>();
- * const json = serializer.serialize(model);
- * const rebuilt = serializer.deserialize(json);
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant DS as DeterministicSerializer
- *   Caller->>DS: serialize(model)
- *   DS->>DS: preSerialize(model)
- *   DS->>DS: sort-keys-recursive
- *   DS->>DS: json-stringify-deterministic
- *   DS-->>Caller: string
- *   Caller->>DS: deserialize(string)
- *   DS-->>Caller: model
- */
-export declare class DeterministicSerializer<M extends Model> extends JSONSerializer<M> {
-    constructor();
-    protected preSerialize(model: M): Record<string, any>;
-    /**
-     * @summary Rebuilds a model from a serialization
-     * @param {string} str
-     *
-     * @throws {Error} If it fails to parse the string, or to build the model
-     */
-    deserialize(str: string): M;
-    /**
-     * @description Serialize a model into a deterministic JSON string
-     * @summary Prepares the model with preSerialize, sorts keys recursively, and stringifies deterministically for stable ordering
-     * @param {M} model - The model instance to serialize
-     * @return {string} Deterministic JSON representation of the model
-     */
-    serialize(model: M): string;
-}

package/lib/types/shared/SimpleDeterministicSerializer.d.ts

@@ -1,7 +0,0 @@
-import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
-export declare class SimpleDeterministicSerializer<M extends Model> extends JSONSerializer<M> {
-    constructor();
-    deserialize(str: string, tableName?: string): M;
-    serialize(model: M, putAnchor?: boolean): string;
-    protected preSerialize(model: M, putAnchor?: boolean): Record<string, any>;
-}

package/lib/types/shared/constants.d.ts

@@ -1,35 +0,0 @@
-/**
- * @description Keys used to mark Fabric-specific model metadata
- * @summary Enumeration of special keys used by the serialization layer to persist Fabric-related flags on models
- * @enum {string}
- * @readonly
- * @memberOf module:for-fabric.shared
- */
-export declare enum FabricModelKeys {
-    /** Private data marker used to tag properties or models for Fabric private collections */
-    PRIVATE = "private",
-    SHARED = "shared",
-    /** Namespace prefix used for Fabric-specific metadata keys */
-    FABRIC = "fabric",
-    OWNED_BY = "owned-by",
-    TRANSACTION_ID = "transaction-id",
-    MIRROR = "mirror"
-}
-/**
- * @description Supported identity types for Fabric credentials
- * @summary Enumeration of identity formats recognized by this library
- * @enum {string}
- * @readonly
- * @memberOf module:for-fabric.shared
- */
-export declare enum IdentityType {
-    /** Standard X.509 identity format used by Hyperledger Fabric */
-    X509 = "X.509"
-}
-/**
- * @description String identifier for the Fabric adapter flavour
- * @summary Used to tag adapters/repositories that operate against Hyperledger Fabric
- * @const FabricFlavour
- * @memberOf module:for-fabric.shared
- */
-export declare const FabricFlavour = "hlf-fabric";

package/lib/types/shared/decorators.d.ts

@@ -1,81 +0,0 @@
-import { Repo, Context, Repository, ContextOf } from "@decaf-ts/core";
-import { Model } from "@decaf-ts/decorator-validation";
-import { ClientIdentity } from "fabric-shim-api";
-import { Constructor } from "@decaf-ts/decoration";
-import { FabricFlags } from "./types";
-import { FabricContractFlags } from "../contracts/types";
-import "../shared/overrides";
-import { type FabricContractContext } from "../contracts/ContractContext";
-/**
- * @description Extracts the MSP ID from either a string or ClientIdentity object
- * @param identity - The identity value which can be a string MSP ID or ClientIdentity object
- * @returns The MSP ID as a string, or undefined if not available
- */
-export declare function extractMspId(identity: string | ClientIdentity | undefined): string | undefined;
-/**
- * Decorator for marking methods that require ownership authorization.
- * Checks the owner of the token before allowing the method to be executed.
- *
- * @example
- * ```typescript
- * class TokenContract extends Contract {
- *   @Owner()
- *   async Mint(ctx: Context, amount: number) {
- *     // Mint token logic
- *   }
- * }
- * ```
- *
- * @returns {MethodDecorator} A method decorator that checks ownership authorization.
- */
-export declare function Owner(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-export declare function ownedByOnCreate<M extends Model<boolean>, R extends Repo<M>, V>(this: R, context: ContextOf<R>, data: V, key: keyof M, model: M): Promise<void>;
-export declare function ownedBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function transactionIdOnCreate<M extends Model<boolean>, R extends Repo<M>, V>(this: R, context: ContextOf<R>, data: V, key: keyof M, model: M): Promise<void>;
-export declare function transactionId(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export type MirrorCondition = (msp: string) => boolean;
-export type MirrorMetadata = {
-    condition?: MirrorCondition;
-    resolver: CollectionResolver | string;
-    mspId: string;
-};
-export declare function evalMirrorMetadata<M extends Model>(model: M, resolver: undefined | string | CollectionResolver, ctx: Context<FabricContractFlags>): Promise<string>;
-export declare function createMirrorHandler<M extends Model, R extends Repository<M, any>>(this: R, context: Context<FabricContractFlags>, data: MirrorMetadata, key: keyof M, model: M): Promise<void>;
-export declare function updateMirrorHandler<M extends Model, R extends Repository<M, any>>(this: R, context: Context<FabricContractFlags>, data: MirrorMetadata, key: keyof M, model: M): Promise<void>;
-export declare function deleteMirrorHandler<M extends Model, R extends Repository<M, any>>(this: R, context: Context<FabricContractFlags>, data: MirrorMetadata, key: keyof M, model: M): Promise<void>;
-export declare function mirrorWriteGuard<M extends Model, R extends Repository<M, any>>(this: R, context: Context<FabricContractFlags>, data: MirrorMetadata, key: keyof M, model: M): Promise<void>;
-export declare function readMirrorHandler<M extends Model, R extends Repository<M, any>>(this: R, context: Context<FabricContractFlags>, data: MirrorMetadata, key: keyof M, model: M): Promise<void>;
-export declare function mirror(collection: CollectionResolver | string, mspIdOrCondition?: string | MirrorCondition, condition?: MirrorCondition): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export type CollectionResolver = <M extends Model>(model: M | Constructor<M>, msp?: string, ...args: any[]) => string;
-export declare const ModelCollection: CollectionResolver;
-export declare function NamespaceCollection(namespace: string): CollectionResolver;
-export declare const ImplicitPrivateCollection: CollectionResolver;
-export type SegregatedDataMetadata = {
-    collections: string | CollectionResolver;
-};
-/**
- * @description Priority for early collection extraction (before pk generation at priority 60)
- * @summary This priority ensures collections are registered in context before any sequence
- * operations occur, allowing sequences to be replicated to private/shared collections.
- */
-export declare const SEGREGATED_COLLECTION_EXTRACTION_PRIORITY = 35;
-export declare function applySegregationFlags<M extends Model>(clazz: M, collections: string[], ctx: any): void;
-export declare function applyMirrorFlags<M extends Model>(clazz: Constructor<M>, msp: string | undefined, ctx: FabricContractContext): Promise<void>;
-/**
- * @description Early handler to extract and register collections in context
- * @summary Runs with priority < 40 to extract collection names before pk generation (priority 60).
- * This allows FabricContractSequence to know which collections to replicate to.
- * @template M - Type that extends Model
- * @param {ContextOf<Repository<M, any>>} context - The execution context
- * @param {SegregatedDataMetadata | SegregatedDataMetadata[]} data - The segregated data metadata
- * @param {string | string[]} keys - The property key(s) being segregated
- * @param {M} model - The model instance
- * @return {Promise<void>}
- */
-export declare function extractSegregatedCollections<M extends Model>(this: Repository<M, any>, context: ContextOf<typeof this>, data: SegregatedDataMetadata | SegregatedDataMetadata[], keys: keyof M | (keyof M)[], model: M): Promise<void>;
-export declare function segregatedDataOnCreate<M extends Model>(this: Repository<M, any>, context: ContextOf<typeof this>, data: SegregatedDataMetadata | SegregatedDataMetadata[], keys: keyof M | (keyof M)[], model: M): Promise<void>;
-export declare function segregatedDataOnRead<M extends Model>(this: Repository<M, any>, context: Context<FabricFlags>, data: SegregatedDataMetadata | SegregatedDataMetadata[], keys: keyof M | (keyof M)[], model: M): Promise<void>;
-export declare function segregatedDataOnUpdate<M extends Model>(this: Repository<M, any>, context: ContextOf<typeof this>, data: SegregatedDataMetadata | SegregatedDataMetadata[], key: keyof M | (keyof M)[], model: M, oldModel: M): Promise<void>;
-export declare function segregatedDataOnDelete<M extends Model, R extends Repository<M, any>, V extends SegregatedDataMetadata>(this: R, context: ContextOf<R>, data: V | V[], key: (keyof M)[], model: M): Promise<void>;
-export declare function privateData(collection?: string | CollectionResolver): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function sharedData(collection: string | CollectionResolver): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/shared/erc20/erc20-constants.d.ts

@@ -1,25 +0,0 @@
-/**
- * Enum representing the events emitted by an ERC20 contract.
- *
- * @remarks
- * This enum is used to identify the specific events that can be emitted by an ERC20 contract.
- * The events are named according to the EIP-20 standard.
- */
-export declare enum ERC20Events {
-    /**
-     * Emitted when a `transfer` function is called successfully.
-     *
-     * @param from - The address of the sender.
-     * @param to - The address of the recipient.
-     * @param value - The amount of tokens transferred.
-     */
-    TRANSFER = "Transfer",
-    /**
-     * Emitted when an `approve` function is called successfully.
-     *
-     * @param owner - The address of the token owner.
-     * @param spender - The address of the approved spender.
-     * @param value - The amount of tokens approved for the spender.
-     */
-    APPROVAL = "Approval"
-}

package/lib/types/shared/erc20/index.d.ts

@@ -1 +0,0 @@
-export * from "./erc20-constants";

package/lib/types/shared/errors.d.ts

@@ -1,140 +0,0 @@
-import { BaseError, InternalError } from "@decaf-ts/db-decorators";
-import { AuthorizationError } from "@decaf-ts/core";
-/**
- * @summary Represents an overflow error in arithmetic operations in Smart Contracts
- *
- * @param {string} msg the error message
- *
- * @class OverflowError
- * @extends InternalError
- *
- * @category Errors
- */
-export declare class OverflowError extends InternalError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents a failure in balance to perform a transaction in Smart Contracts
- *
- * @param {string} msg the error message
- *
- * @class BalanceError
- * @extends InternalError
- *
- * @category Errors
- */
-export declare class BalanceError extends InternalError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents a failure in balance to perform a transaction in Smart Contracts
- *
- * @param {string} msg the error message
- *
- * @class BalanceError
- * @extends InternalError
- *
- * @category Errors
- */
-export declare class AllowanceError extends InternalError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents a failure registrating new entities
- *
- * @param {string} msg the error message
- *
- * @class RegistrationError
- *
- * @categort Errors
- */
-export declare class RegistrationError extends AuthorizationError {
-    constructor(msg: string | Error);
-}
-/**
- * @description Error thrown when an unsupported operation is attempted
- * @summary This error is thrown when an operation is requested that is not supported by the current
- * persistence adapter or configuration. It extends the BaseError class and sets a 500 status code.
- * @param {string|Error} msg - The error message or an Error object to wrap
- * @class UnsupportedError
- * @example
- * ```typescript
- * // Throwing an UnsupportedError
- * if (!adapter.supportsTransactions()) {
- *   throw new UnsupportedError('Transactions are not supported by this adapter');
- * }
- *
- * // Catching an UnsupportedError
- * try {
- *   await adapter.beginTransaction();
- * } catch (error) {
- *   if (error instanceof UnsupportedError) {
- *     console.error('Operation not supported:', error.message);
- *   }
- * }
- * ```
- *
- * @category Errors
- */
-export declare class MissingContextError extends InternalError {
-    constructor(msg: string | Error);
-}
-export declare class UnauthorizedPrivateDataAccess extends BaseError {
-    constructor(msg?: string | Error);
-}
-/**
- * Represents an error that occurs when a required initialization step is not performed.
- *
- * @class NotInitializedError
- * @extends BaseError
- *
- * @category Errors
- *
- * @param {string | Error} msg - The error message or an Error object to wrap.
- *
- * @throws {NotInitializedError} - Throws an error when a required initialization step is not performed.
- *
- * @example
- * ```typescript
- * // Initialize the application
- * if (!isInitialized) {
- *   throw new NotInitializedError('Application is not initialized');
- * }
- *
- * // Catching an NotInitializedError
- * try {
- *   // Perform operations that require initialization
- * } catch (error) {
- *   if (error instanceof NotInitializedError) {
- *     console.error('Initialization error:', error.message);
- *   }
- * }
- * ```
- */
-export declare class NotInitializedError extends BaseError {
-    constructor(msg: string | Error);
-}
-export declare class MissingPKCSS11Lib extends InternalError {
-    constructor(msg: string | Error);
-}
-export declare class EndorsementError extends InternalError {
-    constructor(message: string | Error);
-}
-export declare class MvccReadConflictError extends InternalError {
-    constructor(message: string | Error);
-}
-export declare class PhantomReadConflictError extends InternalError {
-    constructor(message: string | Error);
-}
-export declare class EndorsementPolicyError extends InternalError {
-    constructor(message: string | Error);
-}
-export declare class TransactionLimitsError extends InternalError {
-    constructor(message: string | Error, name?: string, code?: number);
-}
-export declare class TransactionTimeoutError extends InternalError {
-    constructor(message: string | Error);
-}
-export declare class TransactionBufferSizeError extends InternalError {
-    constructor(message: string | Error);
-}