@decaf-ts/for-fabric 0.5.7 → 0.7.1

package/lib/esm/contract/models/Product.d.ts

@@ -1,15 +0,0 @@
-import type { ModelArg } from "@decaf-ts/decorator-validation";
-import { ProductStrength } from "./ProductStrength";
-import { Market } from "./Market";
-import { BaseIdentifiedModel } from "./BaseIdentifiedModel";
-export declare class Product extends BaseIdentifiedModel {
-    productCode: string;
-    inventedName: string;
-    nameMedicinalProduct: string;
-    internalMaterialCode?: string;
-    productRecall: boolean;
-    counter?: number;
-    strengths: ProductStrength[];
-    markets: Market[];
-    constructor(args?: ModelArg<Product>);
-}

package/lib/esm/contract/models/ProductStrength.d.ts

@@ -1,11 +0,0 @@
-import type { ModelArg } from "@decaf-ts/decorator-validation";
-import { BaseIdentifiedModel } from "./BaseIdentifiedModel";
-export declare class ProductStrength extends BaseIdentifiedModel {
-    id: string;
-    uuid: string;
-    productCode: string;
-    strength: string;
-    substance?: string;
-    legalEntityName?: string;
-    constructor(model?: ModelArg<ProductStrength>);
-}

package/lib/esm/contract/models/SegregatedDocument.d.ts

@@ -1,18 +0,0 @@
-import type { ModelArg } from "@decaf-ts/decorator-validation";
-import { BaseIdentifiedModel } from "./BaseIdentifiedModel";
-export declare class SegregatedPrivateDocument extends BaseIdentifiedModel {
-    id: string;
-    title: string;
-    privateNoteA?: string;
-    privateNoteB?: string;
-    owner?: string;
-    constructor(args?: ModelArg<SegregatedPrivateDocument>);
-}
-export declare class SegregatedSharedDocument extends BaseIdentifiedModel {
-    id: string;
-    name: string;
-    sharedNoteA?: string;
-    sharedNoteB?: string;
-    owner?: string;
-    constructor(args?: ModelArg<SegregatedSharedDocument>);
-}

package/lib/esm/contract/models/constants.d.ts

@@ -1,24 +0,0 @@
-export declare const DatePattern = "yyyy-MM-dd";
-export declare const BatchPattern: RegExp;
-export declare enum TableNames {
-    Audit = "audit",
-    Batch = "batch",
-    GtinOwner = "gtin_owner",
-    Leaflet = "leaflet",
-    LeafletFile = "leaflet_file",
-    Product = "product",
-    Market = "market",
-    ProductStrength = "product_strength"
-}
-export declare enum AuditOperations {
-    REMOVE = "Remove user",
-    ADD = "Add user",
-    DEACTIVATE = "Deactivate user",
-    LOGIN = "Access wallet",
-    SHARED_ENCLAVE_CREATE = "Create identity",
-    BREAK_GLASS_RECOVERY = "Wallet recovered with the break Glass Recovery Code",
-    AUTHORIZE = "Authorize integration user",
-    REVOKE = "Revoke integration user",
-    DATA_RECOVERY = "Use of the Data Recovery Key",
-    RECOVERY_KEY_COPIED = "Copy Data Recovery Key"
-}

package/lib/esm/contract/models/decorators-private.d.ts

@@ -1,16 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import { Repository } from "@decaf-ts/core";
-import { FabricContractContext } from "../../contracts/ContractContext";
-import { CollectionResolver } from "../../shared/decorators";
-export declare function rebuildForMatchingCollection<M extends Model>(model: M, context: any, collections: {
-    privateCols: (string | CollectionResolver)[];
-    sharedCols: (string | CollectionResolver)[];
-}): Promise<M>;
-export declare function createAuditHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: AuditMetadata, key: keyof M, model: M): Promise<void>;
-export declare function updateAuditHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: AuditMetadata, key: keyof M, model: M, oldModel: M): Promise<void>;
-export declare function deleteAuditHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: AuditMetadata, key: keyof M, model: M): Promise<void>;
-export type AuditMetadata = {
-    class: Constructor<Model>;
-};
-export declare function audit(model: Constructor<Model<boolean>>): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;

package/lib/esm/contract/models/decorators.d.ts

@@ -1,28 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import { Repo, Repository } from "@decaf-ts/core";
-import { FabricContractContext } from "../../contracts/ContractContext";
-import { CollectionResolver } from "../../shared/decorators";
-export declare function rebuildForMatchingCollection<M extends Model>(model: M, context: any, collections: {
-    privateCols: (string | CollectionResolver)[];
-    sharedCols: (string | CollectionResolver)[];
-}): Promise<M>;
-/**
- * Returns a shallow-cloned copy of the model with relation properties resolved
- * to their full instances. The original model is NOT mutated.
- */
-export declare function populateRelations<M extends Model>(model: M, context: FabricContractContext, overrides?: Record<string, any>): Promise<M>;
-export declare function createAuditHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: AuditMetadata, key: keyof M, model: M): Promise<void>;
-export declare function updateAuditHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: AuditMetadata, key: keyof M, model: M, oldModel: M): Promise<void>;
-export declare function deleteAuditHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: AuditMetadata, key: keyof M, model: M): Promise<void>;
-export type AuditMetadata = {
-    class: Constructor<Model>;
-};
-export declare function audit(model: Constructor<Model<boolean>>): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;
-export declare function createAssignGtinOwnerHandler<M extends Model, R extends Repo<M>, V>(this: R, context: FabricContractContext, data: V, key: keyof M, model: {
-    productCode: string;
-}): Promise<void>;
-export declare function deleteAssignGtinOwnerHandler<M extends Model, R extends Repo<M>, V>(this: R, context: FabricContractContext, data: V, key: keyof M, model: {
-    productCode: string;
-}): Promise<void>;
-export declare function assignProductOwner(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;

package/lib/esm/contract/models/gtin.d.ts

@@ -1,8 +0,0 @@
-import { Validator, ValidatorOptions } from "@decaf-ts/decorator-validation";
-export declare class GtinValidator extends Validator {
-    constructor(message?: string);
-    hasErrors(value: number | string, options?: ValidatorOptions): string | undefined;
-}
-export declare const gtin: (message?: string) => (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;
-export declare function generateGtin(): string;
-export declare function getBatch(): string;

package/lib/esm/contract/models/history-dec.d.ts

@@ -1,6 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { Repository } from "@decaf-ts/core";
-import type { FabricContractContext } from "../../contracts/index";
-export declare function updateHistoryHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: any, key: keyof M, model: M, oldModel: M): Promise<void>;
-export declare function deleteHistoryHandler<M extends Model, R extends Repository<M, any>>(this: R, context: FabricContractContext, data: any, key: keyof M, model: M): Promise<void>;
-export declare function historyDec(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;

package/lib/esm/contracts/ContractAdapter.d.ts

@@ -1,287 +0,0 @@
-import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
-import { Model } from "@decaf-ts/decorator-validation";
-import { FabricContractFlags } from "./types";
-import { FabricContractContext } from "./ContractContext";
-import { BaseError, BulkCrudOperationKeys, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
-import { Context as Ctx } from "fabric-contract-api";
-import { Logger } from "@decaf-ts/logging";
-import { RelationsMetadata, Sequence, SequenceOptions, Adapter, AdapterFlags, PreparedModel, Repository, ContextualizedArgs, Context, RawResult, Paginator, ContextualArgs, MaybeContextualArg, MethodOrOperation, AllOperationKeys, FlagsOf, ContextOf, EventIds, Dispatch } from "@decaf-ts/core";
-import { FabricContractRepository } from "./FabricContractRepository";
-import { ChaincodeStub, ClientIdentity, Iterators, StateQueryResponse } from "fabric-shim-api";
-import { FabricStatement } from "./FabricContractStatement";
-import { SimpleDeterministicSerializer } from "../shared/SimpleDeterministicSerializer";
-import { Constructor } from "@decaf-ts/decoration";
-export type FabricContextualizedArgs<ARGS extends any[] = any[], EXTEND extends boolean = false> = ContextualizedArgs<FabricContractContext, ARGS, EXTEND> & {
-    stub: ChaincodeStub;
-    identity: ClientIdentity;
-};
-/**
- * @description Sets the creator or updater field in a model based on the user in the context
- * @summary Callback function used in decorators to automatically set the created_by or updated_by fields
- * with the username from the context when a document is created or updated
- * @template M - Type extending Model
- * @template R - Type extending NanoRepository<M>
- * @template V - Type extending RelationsMetadata
- * @param {R} this - The repository instance
- * @param {FabricContractContext} context - The operation context containing user information
- * @param {V} data - The relation metadata
- * @param {string} key - The property key to set with the username
- * @param {M} model - The model instance being created or updated
- * @return {Promise<void>} A promise that resolves when the operation is complete
- * @function createdByOnFabricCreateUpdate
- * @memberOf module:fabric.contracts
- * @mermaid
- * sequenceDiagram
- *   participant F as createdByOnNanoCreateUpdate
- *   participant C as Context
- *   participant M as Model
- *   F->>C: get("user")
- *   C-->>F: user object
- *   F->>M: set key to user.name
- *   Note over F: If no user in context
- *   F-->>F: throw UnsupportedError
- */
-export declare function createdByOnFabricCreateUpdate<M extends Model, R extends FabricContractRepository<M>, V extends RelationsMetadata>(this: R, context: ContextOf<R>, data: V, key: keyof M, model: M): Promise<void>;
-/**
- * @description Adapter for Hyperledger Fabric chaincode state database operations
- * @summary Provides a CouchDB-like interface for interacting with the Fabric state database from within a chaincode contract
- * @template void - No configuration needed for contract adapter
- * @template FabricContractFlags - Flags specific to Fabric contract operations
- * @template FabricContractContext - Context type for Fabric contract operations
- * @class FabricContractAdapter
- * @example
- * ```typescript
- * // In a Fabric chaincode contract class
- * import { FabricContractAdapter } from '@decaf-ts/for-fabric';
- *
- * export class MyContract extends Contract {
- *   private adapter = new FabricContractAdapter();
- *
- *   @Transaction()
- *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {
- *     const model = { id, data, timestamp: Date.now() };
- *     await this.adapter.create('assets', id, model, {}, { stub: ctx.stub });
- *   }
- * }
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Contract
- *   participant FabricContractAdapter
- *   participant Stub
- *   participant StateDB
- *
- *   Contract->>FabricContractAdapter: create(tableName, id, model, transient, ctx)
- *   FabricContractAdapter->>FabricContractAdapter: Serialize model to JSON
- *   FabricContractAdapter->>Stub: putState(id, serializedData)
- *   Stub->>StateDB: Write data
- *   StateDB-->>Stub: Success
- *   Stub-->>FabricContractAdapter: Success
- *   FabricContractAdapter-->>Contract: model
- */
-export declare class FabricContractAdapter extends CouchDBAdapter<any, void, FabricContractContext> {
-    private static readonly PRIVATE_BOOKMARK_PREFIX;
-    private static parseSyntheticPrivateBookmark;
-    private static buildSyntheticPrivateBookmark;
-    protected getClient(): void;
-    /**
-     * @description Text decoder for converting binary data to strings
-     */
-    private static textDecoder;
-    protected static readonly serializer: SimpleDeterministicSerializer<Model<false>>;
-    /**
-     * @description Context constructor for this adapter
-     * @summary Overrides the base Context constructor with FabricContractContext
-     */
-    protected get Context(): Constructor<FabricContractContext>;
-    /**
-     * @description Gets the repository constructor for this adapter
-     * @summary Returns the FabricContractRepository constructor for creating repositories
-     * @template M - Type extending Model
-     * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor
-     */
-    repository<R extends Repository<any, Adapter<any, void, MangoQuery, Context<FabricContractFlags>>>>(): Constructor<R>;
-    Paginator<M extends Model>(query: MangoQuery, size: number, clazz: Constructor<M>): Paginator<M, any, MangoQuery>;
-    Sequence(options: SequenceOptions): Promise<Sequence>;
-    protected Dispatch(): Dispatch<FabricContractAdapter>;
-    /**
-     * @description Creates a new FabricContractAdapter instance
-     * @summary Initializes an adapter for interacting with the Fabric state database
-     * @param {void} scope - Not used in this adapter
-     * @param {string} [alias] - Optional alias for the adapter instance
-     */
-    constructor(scope: void, alias?: string);
-    for(config: Partial<any>, ...args: any): typeof this;
-    protected getModelDefaults<M extends Model>(clazz: Constructor<M>): Record<keyof M, any>;
-    /**
-     * @description Creates a record in the state database
-     * @summary Serializes a model and stores it in the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier
-     * @param {Record<string, any>} model - The record data
-     * @param {Record<string, any>} transient - Transient data (not used in this implementation)
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the created record
-     */
-    create<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    createAll<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, any>[]>;
-    /**
-     * @description Reads a record from the state database
-     * @summary Retrieves and deserializes a record from the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
-     */
-    read<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Retrieves multiple records from the database
-     * @summary Fetches multiple records with the given IDs from the specified table
-     * @param {string} tableName - The name of the table to read from
-     * @param id - The identifiers of the records to retrieve
-     * @param {...any[]} args - Additional arguments specific to the adapter implementation
-     * @return A promise that resolves to an array of retrieved records
-     */
-    readAll<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType[], ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Updates a record in the state database
-     * @summary Serializes a model and updates it in the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier
-     * @param {Record<string, any>} model - The updated record data
-     * @param {Record<string, any>} transient - Transient data (not used in this implementation)
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the updated record
-     */
-    update<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Deletes a record from the state database
-     * @summary Retrieves a record and then removes it from the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier to delete
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
-     */
-    delete<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    protected deleteState(id: string, context: FabricContractContext): Promise<void>;
-    forPrivate(collection: string): FabricContractAdapter;
-    protected putState(id: string, model: Record<string, any>, ctx: FabricContractContext): Promise<Record<string, any>>;
-    protected readState(id: string, ctx: FabricContractContext): Promise<any>;
-    protected queryResult(stub: ChaincodeStub, rawInput: any, ...args: ContextualArgs<FabricContractContext>): Promise<Iterators.StateQueryIterator>;
-    protected queryResultPaginated(stub: ChaincodeStub, rawInput: any, limit?: number, page?: number, bookmark?: string | number, ...args: any[]): Promise<StateQueryResponse<Iterators.StateQueryIterator>>;
-    /**
-     * @description Decodes binary data to string
-     * @summary Converts a Uint8Array to a string using UTF-8 encoding
-     * @param {Uint8Array} buffer - The binary data to decode
-     * @return {string} The decoded string
-     */
-    protected decode(buffer: Uint8Array): string;
-    /**
-     * @description Creates operation flags for Fabric contract operations
-     * @summary Merges default flags with Fabric-specific context information
-     * @template M - Type extending Model
-     * @param {OperationKeys} operation - The operation being performed
-     * @param {Constructor<M>} model - The model constructor
-     * @param {Partial<FabricContractFlags>} flags - Partial flags to merge with defaults
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @return {FabricContractFlags} The merged flags
-     */
-    protected flags<M extends Model>(operation: AllOperationKeys, model: Constructor<M> | undefined, flags: Partial<FabricContractFlags> | FabricContractContext | Ctx | any): Promise<FabricContractFlags>;
-    /**
-     * @description Creates an index for a model
-     * @summary This method is not implemented for Fabric contracts and returns a resolved promise
-     * @template M - Type extending Model
-     * @param {Constructor<M>} models - The model constructor
-     * @return {Promise<void>} Promise that resolves immediately
-     */
-    protected index<M>(models: Constructor<M>): Promise<void>;
-    /**
-     * @description Processes results from a state query iterator
-     * @summary Iterates through query results and converts them to a structured format
-     * @param {Logger} log - Logger instance for debugging
-     * @param {Iterators.StateQueryIterator} iterator - The state query iterator
-     * @param {boolean} [isHistory=false] - Whether this is a history query
-     * @return {Promise<any[]>} Promise resolving to an array of processed results
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant ResultIterator
-     *   participant Iterator
-     *
-     *   Caller->>ResultIterator: resultIterator(log, iterator, isHistory)
-     *   loop Until done
-     *     ResultIterator->>Iterator: next()
-     *     Iterator-->>ResultIterator: { value, done }
-     *     alt Has value
-     *       ResultIterator->>ResultIterator: Process value based on isHistory
-     *       ResultIterator->>ResultIterator: Add to results array
-     *     end
-     *   end
-     *   ResultIterator->>Iterator: close()
-     *   ResultIterator-->>Caller: allResults
-     */
-    protected resultIterator(log: Logger, iterator: Iterators.StateQueryIterator, isHistory?: boolean): Promise<any[]>;
-    /**
-     * @description Executes a raw query against the state database
-     * @summary Performs a rich query using CouchDB syntax against the Fabric state database
-     * @template R - The return type
-     * @param {MangoQuery} rawInput - The Mango Query to execute
-     * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<R>} Promise resolving to the query results
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant FabricContractAdapter
-     *   participant Stub
-     *   participant StateDB
-     *
-     *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)
-     *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip
-     *   alt With pagination
-     *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)
-     *   else Without pagination
-     *     FabricContractAdapter->>Stub: getQueryResult(query)
-     *   end
-     *   Stub->>StateDB: Execute query
-     *   StateDB-->>Stub: Iterator
-     *   Stub-->>FabricContractAdapter: Iterator
-     *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
-     *   FabricContractAdapter-->>Caller: results
-     */
-    raw<R, D extends boolean>(rawInput: MangoQuery, docsOnly?: D, ...args: ContextualArgs<FabricContractContext>): Promise<RawResult<R, D>>;
-    view<R>(ddoc: string, viewName: string, options: Record<string, any>, ..._args: ContextualArgs<FabricContractContext>): Promise<ViewResponse<R>>;
-    Statement<M extends Model>(overrides?: Partial<AdapterFlags>): FabricStatement<M, any>;
-    updateAll<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, any>[]>;
-    /**
-     *
-     * @param model
-     * @param {string} pk
-     * @param args
-     */
-    prepare<M extends Model>(model: M, ...args: ContextualArgs<FabricContractContext>): PreparedModel & {
-        segregated?: Record<string, Record<string, any>>;
-    };
-    revert<M extends Model>(obj: Record<string, any>, clazz: Constructor<M>, id: PrimaryKeyType, transient?: Record<string, any>, ...args: ContextualArgs<FabricContractContext>): M;
-    private shouldRebuildWithTransient;
-    private getContextMsp;
-    private enforceMirrorAuthorization;
-    createPrefix<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: MaybeContextualArg<FabricContractContext>): [Constructor<M>, PrimaryKeyType, Record<string, any>, ...any[], FabricContractContext];
-    updatePrefix<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: MaybeContextualArg<FabricContractContext>): any[];
-    protected createAllPrefix<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: [...any, FabricContractContext]): (string | string[] | number[] | Record<string, any>[])[];
-    protected updateAllPrefix<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: [...any, FabricContractContext]): any[];
-    parseError<E extends BaseError>(err: Error | string, reason?: string): E;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD): FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false): FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<FabricContractContext>>): Promise<FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>>;
-    updateObservers(table: Constructor<any> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
-    static parseError<E extends BaseError>(err: Error | string): E;
-    /**
-     * @description Static method for decoration overrides
-     * @summary Overrides/extends decaf decoration with Fabric-specific functionality
-     * @static
-     * @override
-     * @return {void}
-     */
-    static decoration(): void;
-}

package/lib/esm/contracts/ContractContext.d.ts

@@ -1,89 +0,0 @@
-import { Context } from "@decaf-ts/core";
-import { FabricContractFlags } from "./types";
-import { ChaincodeStub, ClientIdentity } from "fabric-shim-api";
-/**
- * @description Context class for Fabric chaincode operations
- * @summary Provides access to Fabric-specific context elements like stub, identity, and logger to be used by repositories and adapters during contract execution.
- * @template F - Flags specific to Fabric contract operations
- * @param {object} [args] - Optional initialization arguments passed to the base Context
- * @return {void}
- * @class FabricContractContext
- * @example
- * ```typescript
- * // In a Fabric chaincode contract method
- * const context = new FabricContractContext();
- * // Optionally set values via the base Context API
- * context.set('stub', ctx.stub);
- * context.set('clientIdentity', ctx.clientIdentity);
- * context.set('logger', contractLogger);
- *
- * // Access context properties
- * const timestamp = context.timestamp;
- * const creator = context.identity.getID();
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Contract
- *   participant Context
- *   participant Ledger
- *   Contract->>Context: new FabricContractContext()
- *   Contract->>Context: set('stub'|'clientIdentity'|'logger', ...)
- *   Context-->>Contract: timestamp, identity, logger
- *   Contract->>Ledger: Interact via stub
- */
-export declare class FabricContractContext extends Context<FabricContractFlags> {
-    /**
-     * @description Creates a new FabricContractContext instance
-     * @summary Initializes the context with Fabric-specific flags
-     */
-    constructor(ctx?: FabricContractContext);
-    /**
-     * @description Gets the chaincode stub
-     * @summary Returns the ChaincodeStub instance for interacting with the ledger
-     * @return {ChaincodeStub} The chaincode stub
-     */
-    get stub(): ChaincodeStub;
-    /**
-     * @description Gets the transaction timestamp
-     * @summary Overrides the base timestamp getter to use the stub's timestamp
-     * @return {Date} The transaction timestamp
-     */
-    get timestamp(): Date;
-    /**
-     * @description Gets the client identity
-     * @summary Returns the ClientIdentity instance for the transaction submitter
-     * @return {ClientIdentity} The client identity
-     */
-    get identity(): ClientIdentity;
-    /**
-     * @description Stores segregation metadata per sequence name
-     * @summary Needed because the Sequence creates its own context (via logCtx),
-     * losing flags set by extractSegregatedCollections on the handler context.
-     * The adapter persists across operations, making it a reliable store.
-     */
-    setSequenceSegregation(seqName: string, fullySegregated: boolean, collections: string[]): void;
-    getSequenceSegregation(seqName: string): {
-        fullySegregated: boolean;
-        collections: string[];
-    } | undefined;
-    markFullySegregated(): void;
-    get isFullySegregated(): boolean;
-    writeTo(col: string, entry: string[]): void;
-    getSegregatedWrites(): Record<string, string[]> | undefined;
-    put(key: string, value: any): void;
-    readFrom(cols: string | string[]): void;
-    consumeReadCollections(): string[];
-    /**
-     * @description Gets the collections registered for writing
-     * @summary Returns collection names from segregateWrite, used by sequences to know where to replicate.
-     * @return {string[]} Array of collection names, empty if none registered
-     */
-    getWriteCollections(): string[];
-    /**
-     * @description Gets the collections registered for reading
-     * @summary Returns collection names from segregateRead.
-     * @return {string[]} Array of collection names, empty if none registered
-     */
-    getReadCollections(): string[];
-    toString(): string;
-}

package/lib/esm/contracts/FabricContractDispatch.d.ts

@@ -1,7 +0,0 @@
-import { Dispatch, MaybeContextualArg } from "@decaf-ts/core";
-import { type FabricContractAdapter } from "./ContractAdapter";
-import { FabricContractContext } from "./ContractContext";
-export declare class FabricContractDispatch extends Dispatch<FabricContractAdapter> {
-    constructor();
-    protected initialize(...args: MaybeContextualArg<FabricContractContext>): Promise<void>;
-}

package/lib/esm/contracts/FabricContractRepository.d.ts

@@ -1,119 +0,0 @@
-import "./overrides";
-import { Repository, ObserverHandler, EventIds, ContextualArgs, MaybeContextualArg, OrderDirection, SerializedPage, DirectionLimitOffset, MethodOrOperation, ContextualizedArgs } from "@decaf-ts/core";
-import { FabricContractContext } from "./ContractContext";
-import { Model } from "@decaf-ts/decorator-validation";
-import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
-import { Constructor } from "@decaf-ts/decoration";
-import { FabricContractAdapter } from "./ContractAdapter";
-import { FabricContractFlags } from "./types";
-/**
- * @description Repository for Hyperledger Fabric chaincode models
- * @summary Provides CRUD operations for models within Fabric chaincode contracts
- * @template M - Type extending Model
- * @template MangoQuery - Query type for CouchDB-like queries
- * @template FabricContractAdapter - Adapter type for Fabric contract operations
- * @template FabricContractFlags - Flags specific to Fabric contract operations
- * @template FabricContractContext - Context type for Fabric contract operations
- *
- * @param {FabricContractAdapter} [adapter] - The adapter for interacting with the state database
- * @param {Constructor<M>} [clazz] - The model constructor
- * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [trackedEvents] - Events to track for observer notifications
- *
- * @class FabricContractRepository
- * @example
- * ```typescript
- * // In a Fabric chaincode contract class
- * import { FabricContractRepository, FabricContractAdapter } from '@decaf-ts/for-fabric';
- *
- * @table('assets')
- * class Asset extends Model {
- *   @id()
- *   id: string;
- *
- *   @property()
- *   data: string;
- * }
- *
- * export class MyContract extends Contract {
- *   private adapter = new FabricContractAdapter();
- *   private repository: FabricContractRepository<Asset>;
- *
- *   constructor() {
- *     super('MyContract');
- *     this.repository = new FabricContractRepository<Asset>(this.adapter, Asset);
- *   }
- *
- *   @Transaction()
- *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {
- *     const asset = new Asset();
- *     asset.id = id;
- *     asset.data = data;
- *
- *     await this.repository.create(asset, { stub: ctx.stub });
- *   }
- * }
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Contract
- *   participant Repository
- *   participant Adapter
- *   participant StateDB
- *
- *   Contract->>Repository: create(model, ctx)
- *   Repository->>Adapter: prepare(model, pk)
- *   Repository->>Adapter: create(tableName, id, record, transient, ctx)
- *   Adapter->>StateDB: putState(id, serializedData)
- *   StateDB-->>Adapter: Success
- *   Adapter-->>Repository: record
- *   Repository->>Adapter: revert(record, class, pk, id, transient)
- *   Adapter-->>Repository: model
- *   Repository-->>Contract: model
- */
-export declare class FabricContractRepository<M extends Model> extends Repository<M, FabricContractAdapter> {
-    protected omittedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[] | undefined;
-    protected _overrides: Partial<(import("@decaf-ts/db-decorators").ContextFlags<any> & Pick<import("@decaf-ts/db-decorators").RepositoryFlags<any>, "operation" | "correlationId" | "ignoreDevSafeGuards" | "parentContext" | "childContexts"> & {
-        pending?: Record<string, string[]>;
-        transactionLock?: import("@decaf-ts/core").ContextLock;
-    }) | import("@decaf-ts/core").AdapterFlags> & {
-        ignoreValidation: boolean;
-        ignoreHandlers: boolean;
-        allowRawStatements: boolean;
-        forcePrepareSimpleQueries: boolean;
-        forcePrepareComplexQueries: boolean;
-        rebuildWithTransient: boolean;
-    };
-    constructor(adapter?: FabricContractAdapter, clazz?: Constructor<M>, omittedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[] | undefined);
-    create(model: M, ...args: MaybeContextualArg<FabricContractContext>): Promise<M>;
-    createAll(models: M[], ...args: MaybeContextualArg<FabricContractContext>): Promise<M[]>;
-    update(model: M, ...args: MaybeContextualArg<FabricContractContext>): Promise<M>;
-    updateAll(models: M[], ...args: MaybeContextualArg<FabricContractContext>): Promise<M[]>;
-    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<FabricContractContext>): Promise<M[]>;
-    paginateBy(key: keyof M, order: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<FabricContractContext>): Promise<SerializedPage<M>>;
-    statement(name: string, ...args: MaybeContextualArg<FabricContractContext>): Promise<any>;
-    /**
-     * @description Gets the observer handler for this repository
-     * @summary Returns a FabricContractRepositoryObservableHandler instance
-     * @return {ObserverHandler} The observer handler
-     */
-    ObserverHandler(): ObserverHandler;
-    /**
-     * @description Updates observers based on tracked events
-     * @summary Filters events based on trackedEvents and delegates to the parent method
-     * @param {string} table - The table/collection name
-     * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type
-     * @param {EventIds} id - The event identifier
-     * @param {FabricContractContext} ctx - The Fabric contract context
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<void>} Promise that resolves when observers are updated
-     */
-    updateObservers(table: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD): ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false): ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: true): Promise<ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FabricContractFlags>): Promise<ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FabricContractFlags>): ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>;
-    private cleanContextualizedArgs;
-    private applyCleanContext;
-    private cleanContext;
-}