@decaf-ts/for-fabric 0.8.0 → 0.10.0

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

@@ -0,0 +1,52 @@
+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/ClientSerializer.d.mts

@@ -0,0 +1,52 @@
+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.cts

@@ -0,0 +1,47 @@
+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/DeterministicSerializer.d.mts

@@ -0,0 +1,47 @@
+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.cts

@@ -0,0 +1,7 @@
+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/SimpleDeterministicSerializer.d.mts

@@ -0,0 +1,7 @@
+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.cts

@@ -0,0 +1,35 @@
+/**
+ * @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/constants.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @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.cts

@@ -0,0 +1,81 @@
+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.cjs";
+import { FabricContractFlags } from "../contracts/types.cjs";
+import "../shared/overrides";
+import { type FabricContractContext } from "../contracts/ContractContext.cjs";
+/**
+ * @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/decorators.d.mts

@@ -0,0 +1,81 @@
+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.js";
+import { FabricContractFlags } from "../contracts/types.js";
+import "../shared/overrides";
+import { type FabricContractContext } from "../contracts/ContractContext.js";
+/**
+ * @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.cts

@@ -0,0 +1,25 @@
+/**
+ * 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/erc20-constants.d.mts

@@ -0,0 +1,25 @@
+/**
+ * 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.cts

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

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

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

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

@@ -0,0 +1,140 @@
+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);
+}