@decaf-ts/for-fabric 0.8.0 → 0.10.0

package/lib/types/contracts/ContractAdapter.d.cts

@@ -0,0 +1,287 @@
+import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
+import { Model } from "@decaf-ts/decorator-validation";
+import { FabricContractFlags } from "./types.cjs";
+import { FabricContractContext } from "./ContractContext.cjs";
+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.cjs";
+import { ChaincodeStub, ClientIdentity, Iterators, StateQueryResponse } from "fabric-shim-api";
+import { FabricStatement } from "./FabricContractStatement.cjs";
+import { SimpleDeterministicSerializer } from "../shared/SimpleDeterministicSerializer.cjs";
+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/types/contracts/ContractAdapter.d.mts

@@ -0,0 +1,287 @@
+import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
+import { Model } from "@decaf-ts/decorator-validation";
+import { FabricContractFlags } from "./types.js";
+import { FabricContractContext } from "./ContractContext.js";
+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.js";
+import { ChaincodeStub, ClientIdentity, Iterators, StateQueryResponse } from "fabric-shim-api";
+import { FabricStatement } from "./FabricContractStatement.js";
+import { SimpleDeterministicSerializer } from "../shared/SimpleDeterministicSerializer.js";
+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;
+}