@decaf-ts/for-fabric 0.11.0 → 0.12.0

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

@@ -1,62 +0,0 @@
-import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
-import { ContextualArgs, EventIds, ObserverHandler } from "@decaf-ts/core";
-import { FabricContractContext } from "./ContractContext";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Observer handler for Fabric chaincode events
- * @summary Emits events on the Fabric ledger when repository operations occur
- * @class FabricContractRepositoryObservableHandler
- * @extends {ObserverHandler}
- * @example
- * ```typescript
- * // In a Fabric chaincode contract
- * import { FabricContractRepositoryObservableHandler } from '@decaf-ts/for-fabric';
- *
- * // Create a handler with default supported events
- * const handler = new FabricContractRepositoryObservableHandler();
- *
- * // Emit an event
- * await handler.updateObservers(
- *   logger,
- *   'assets',
- *   OperationKeys.CREATE,
- *   'asset1',
- *   context
- * );
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Repository
- *   participant ObservableHandler
- *   participant Stub
- *   participant Ledger
- *
- *   Repository->>ObservableHandler: updateObservers(log, table, event, id, ctx)
- *   ObservableHandler->>ObservableHandler: Check if event is supported
- *   ObservableHandler->>ObservableHandler: generateFabricEventName(table, event, owner)
- *   ObservableHandler->>Stub: setEvent(eventName, payload)
- *   Stub->>Ledger: Record event
- */
-export declare class FabricContractRepositoryObservableHandler extends ObserverHandler {
-    private supportedEvents;
-    /**
-     * @description Creates a new FabricContractRepositoryObservableHandler instance
-     * @summary Initializes the handler with a list of supported events
-     * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [supportedEvents] - Events that will trigger Fabric events
-     */
-    constructor(supportedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[]);
-    /**
-     * @description Updates observers by emitting Fabric events
-     * @summary Emits events on the Fabric ledger for supported event types
-     * @param {Logger} log - Logger instance for debugging
-     * @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 {string} [owner] - Optional owner identifier for the event
-     * @param {object | string | undefined} [owner] - Optional payload for the event
-     *
-     * @return {Promise<void>} Promise that resolves when the event is emitted
-     */
-    updateObservers(clazz: string | Constructor<any>, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
-}

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

@@ -1,87 +0,0 @@
-import { Adapter, Context, MaybeContextualArg, Sequence, SequenceOptions } from "@decaf-ts/core";
-/**
- * @description Abstract base class for sequence generation
- * @summary Provides a framework for generating sequential values (like primary keys) in the persistence layer.
- * Implementations of this class handle the specifics of how sequences are stored and incremented in different
- * database systems.
- * @param {SequenceOptions} options - Configuration options for the sequence generator
- * @class Sequence
- * @example
- * ```typescript
- * // Example implementation for a specific database
- * class PostgresSequence extends Sequence {
- *   constructor(options: SequenceOptions) {
- *     super(options);
- *   }
- *
- *   async next(): Promise<number> {
- *     // Implementation to get next value from PostgreSQL sequence
- *     const result = await this.options.executor.raw(`SELECT nextval('${this.options.name}')`);
- *     return parseInt(result.rows[0].nextval);
- *   }
- *
- *   async current(): Promise<number> {
- *     // Implementation to get current value from PostgreSQL sequence
- *     const result = await this.options.executor.raw(`SELECT currval('${this.options.name}')`);
- *     return parseInt(result.rows[0].currval);
- *   }
- *
- *   async range(count: number): Promise<number[]> {
- *     // Implementation to get a range of values
- *     const values: number[] = [];
- *     for (let i = 0; i < count; i++) {
- *       values.push(await this.next());
- *     }
- *     return values;
- *   }
- * }
- *
- * // Usage
- * const sequence = new PostgresSequence({
- *   name: 'user_id_seq',
- *   executor: dbExecutor
- * });
- *
- * const nextId = await sequence.next();
- * ```
- */
-export declare class FabricContractSequence extends Sequence {
-    /**
-     * @description Creates a new sequence instance
-     * @summary Protected constructor that initializes the sequence with the provided options
-     */
-    constructor(options: SequenceOptions, adapter: Adapter<any, any, any>);
-    /**
-     * @description Retrieves the current value of the sequence
-     * @summary Gets the current value of the sequence from storage. If the sequence
-     * doesn't exist yet, it returns the configured starting value.
-     * @return A promise that resolves to the current sequence value
-     */
-    current(...args: MaybeContextualArg<any>): Promise<string | number | bigint>;
-    /**
-     * @description Increments the sequence value
-     * @summary Increases the current sequence value by the specified amount and persists
-     * the new value to storage. This method handles both numeric and BigInt sequence types.
-     * @param {string | number | bigint} current - The current value of the sequence
-     * @param {number} [count] - Optional amount to increment by, defaults to the sequence's incrementBy value
-     * @return A promise that resolves to the new sequence value after incrementing
-     */
-    protected increment(count: number | undefined, ctx: Context<any>): Promise<string | number | bigint>;
-    /**
-     * @description Ensures the sequence exists and is at least a given value
-     * @summary Fabric needs to respect segregated/private/shared storage rules when creating
-     * sequences (for example for persistent @version(true) and @sequence()).
-     */
-    ensureAtLeast(value: string | number | bigint, ...args: MaybeContextualArg<any>): Promise<string | number | bigint>;
-    /**
-     * @description Replicates the sequence to all segregated collections
-     * @summary When a model uses privateData or sharedData decorators, its sequence must be
-     * replicated to all collections the model is stored in. This ensures clients with access
-     * to only one collection can still read the model's sequence, while clients without
-     * access to any collection won't see the sequence on the public chain.
-     * @param {Context<any>} ctx - The execution context
-     * @param {SequenceModel} seq - The sequence model to replicate
-     */
-    private writeSequenceToCollections;
-    private replicateToSegregatedCollections;
-}

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

@@ -1,36 +0,0 @@
-import { CouchDBAdapter, MangoQuery } from "@decaf-ts/for-couchdb";
-import { Model } from "@decaf-ts/decorator-validation";
-import { FabricContractContext } from "./ContractContext";
-import { CouchDBStatement } from "@decaf-ts/for-couchdb";
-import { AdapterFlags, MaybeContextualArg } from "@decaf-ts/core";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Statement wrapper for executing Mango queries within Fabric contracts
- * @summary Bridges CouchDB-style queries to Fabric via the FabricContractAdapter, handling identity and primary key projection when needed.
- * @template M - Model type this statement operates on
- * @template R - Result type returned by the statement
- * @param {FabricContractAdapter} adapter - The Fabric contract adapter used for raw execution
- * @param {FabricContractContext} ctx - The Fabric contract context carrying stub and identity
- * @return {void}
- * @class FabricStatement
- * @example
- * const stmt = new FabricStatement<MyModel, MyModel[]>(adapter, ctx);
- * const result = await stmt.raw<MyModel[]>({ selector: { type: 'MyModel' } });
- * @mermaid
- * sequenceDiagram
- *   participant App
- *   participant Statement
- *   participant Adapter
- *   participant Ledger
- *   App->>Statement: raw({ selector })
- *   Statement->>Adapter: adapter.raw(mango, true, ctx)
- *   Adapter->>Ledger: Evaluate query
- *   Adapter-->>Statement: rows
- *   Statement-->>App: models
- */
-export declare class FabricStatement<M extends Model, R> extends CouchDBStatement<M, CouchDBAdapter<any, void, FabricContractContext>, R> {
-    constructor(adapter: CouchDBAdapter<any, void, FabricContractContext>, overrides?: Partial<AdapterFlags>);
-    protected executionPrefix(method: any, ...args: MaybeContextualArg<FabricContractContext>): Promise<[Constructor<M>, ...any[], any]>;
-    protected build(): MangoQuery;
-    execute(...args: MaybeContextualArg<FabricContractContext>): Promise<R>;
-}

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

@@ -1,22 +0,0 @@
-import { Context as Ctx, Contract } from "fabric-contract-api";
-import { MaybeContextualArg, MethodOrOperation } from "@decaf-ts/core";
-import { FabricContextualizedArgs, FabricContractAdapter } from "./ContractAdapter";
-import { healthcheck } from "../shared/index";
-import { FabricContractContext } from "./ContractContext";
-export declare class MigrationContract extends Contract {
-    private _adapter?;
-    protected initialized: boolean;
-    constructor();
-    protected get adapter(): FabricContractAdapter;
-    migrate(context: Ctx, reference: string, migrationArgs?: string): Promise<void>;
-    protected getRegisteredMigrations(context: FabricContractContext): Array<{
-        class: any;
-        reference: string;
-        flavour: string;
-    }>;
-    protected init(ctx: Ctx | FabricContractContext): Promise<void>;
-    healthcheck(ctx: Ctx | FabricContractContext): Promise<string | healthcheck>;
-    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): Promise<FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>>;
-}

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

@@ -1,15 +0,0 @@
-import { BaseModel } from "@decaf-ts/core";
-import { type ModelArg } from "@decaf-ts/decorator-validation";
-export declare class CustomizableSequence extends BaseModel {
-    /**
-     * @description The unique identifier for the sequence
-     * @summary Primary key for the sequence record
-     */
-    id: string;
-    /**
-     * @description The current value of the sequence
-     * @summary Current sequence value that can be incremented
-     */
-    current: string | number;
-    constructor(seq?: ModelArg<CustomizableSequence>);
-}

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

@@ -1,6 +0,0 @@
-import { AuthHandler, AuthorizationError } from "@decaf-ts/core";
-export declare function hlfAllowIf(handler: AuthHandler, ...argz: any[]): (obj: object, propertyKey?: any, descriptor?: any) => void;
-export declare function mspHandler(...args: any[]): AuthorizationError | undefined;
-export declare function namespaceHandler(...args: any[]): AuthorizationError | undefined;
-export declare function onlyMsp(msp: string): (obj: object, propertyKey?: any, descriptor?: any) => void;
-export declare function onlyNamespaceRole(namespace: string, role?: string): (obj: object, propertyKey?: any, descriptor?: any) => void;

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

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

package/lib/types/contracts/crud/crud-contract.d.ts

@@ -1,199 +0,0 @@
-import "../../shared/overrides";
-import { FabricContextualizedArgs, FabricContractAdapter } from "../ContractAdapter";
-import { Context as Ctx, Contract } from "fabric-contract-api";
-import { Model } from "@decaf-ts/decorator-validation";
-import { AllOperationKeys, Condition, ContextualArgs, DirectionLimitOffset, EventIds, MaybeContextualArg, MethodOrOperation, Observer, OrderDirection, PersistenceObserver, SerializedPage } from "@decaf-ts/core";
-import { FabricContractRepository } from "../FabricContractRepository";
-import { DeterministicSerializer } from "../../shared/DeterministicSerializer";
-import { MangoQuery } from "@decaf-ts/for-couchdb";
-import { Checkable, healthcheck } from "../../shared/interfaces/Checkable";
-import { Constructor } from "@decaf-ts/decoration";
-import { FabricContractContext } from "../ContractContext";
-import { PrimaryKeyType } from "@decaf-ts/db-decorators";
-/**
- * @description Base contract class for CRUD operations in Fabric chaincode
- * @summary Provides standard create, read, update, and delete operations for models in Fabric chaincode
- * @template M - Type extending Model
- * @class FabricCrudContract
- * @extends {Contract}
- * @example
- * ```typescript
- * // Define a model
- * @table('assets')
- * class Asset extends Model {
- *   @id()
- *   id: string;
- *
- *   @property()
- *   data: string;
- * }
- *
- * // Create a contract that extends FabricCrudContract
- * export class AssetContract extends FabricCrudContract<Asset> {
- *   constructor() {
- *     super('AssetContract', Asset);
- *   }
- *
- *   // Add custom methods as needed
- *   async getAssetHistory(ctx: Context, id: string): Promise<any[]> {
- *     // Custom implementation
- *   }
- * }
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant Contract
- *   participant Repository
- *   participant Adapter
- *   participant StateDB
- *
- *   Client->>Contract: create(ctx, model)
- *   Contract->>Repository: repository(ctx)
- *   Contract->>Repository: create(model, ctx)
- *   Repository->>Adapter: create(tableName, id, record, transient, ctx)
- *   Adapter->>StateDB: putState(id, serializedData)
- *   StateDB-->>Adapter: Success
- *   Adapter-->>Repository: record
- *   Repository-->>Contract: model
- *   Contract-->>Client: model
- */
-export declare abstract class FabricCrudContract<M extends Model> extends Contract implements Checkable, PersistenceObserver<FabricContractContext>, Observer<[
-    table: Constructor<M> | string,
-    event: AllOperationKeys,
-    id: EventIds,
-    ...args: ContextualArgs<FabricContractContext>
-]> {
-    protected readonly clazz: Constructor<M>;
-    /**
-     * @description Shared adapter instance for all contract instances
-     */
-    protected static adapter: FabricContractAdapter;
-    protected static readonly serializer: DeterministicSerializer<Model<false>>;
-    protected initialized: boolean;
-    private _repo?;
-    protected get repo(): FabricContractRepository<M>;
-    /**
-     * @description Creates a new FabricCrudContract instance
-     * @summary Initializes a contract with a name and model class
-     * @param {string} name - The name of the contract
-     * @param {Constructor<M>} clazz - The model constructor
-     */
-    protected constructor(name: string, clazz: Constructor<M>);
-    refresh(table: Constructor<M> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
-    listBy(ctx: Ctx | FabricContractContext, key: string | keyof M, order: string, ...args: any[]): Promise<M[] | string>;
-    paginateBy(ctx: Ctx | FabricContractContext, key: string | keyof M, order: string, ref?: Omit<DirectionLimitOffset, "direction"> | string, ...args: any[]): Promise<SerializedPage<M> | string>;
-    page(ctx: Ctx | FabricContractContext, value: string, direction?: string | OrderDirection, ref?: Omit<DirectionLimitOffset, "direction"> | string, ...args: any[]): Promise<SerializedPage<M> | string>;
-    findOneBy(ctx: Ctx | FabricContractContext, key: string | keyof M, value: any, ...args: any[]): Promise<M | string>;
-    statement(ctx: Ctx | FabricContractContext, method: string, ...args: any[]): Promise<any>;
-    countOf(ctx: Ctx | FabricContractContext, key?: string | keyof M, ...args: any[]): Promise<number | string>;
-    maxOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M] | string>;
-    minOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M] | string>;
-    avgOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<number | string>;
-    sumOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<number | string>;
-    distinctOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M][] | string>;
-    groupOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<Record<string, M[]> | string>;
-    /**
-     * @description Creates a single model in the state database
-     * @summary Delegates to the repository's create method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {M} model - The model to create
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the created model
-     */
-    create(context: Ctx | FabricContractContext, model: string | M, ...args: any[]): Promise<string | M>;
-    /**
-     * @description Reads a single model from the state database
-     * @summary Delegates to the repository's read method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {string | number} key - The key of the model to read
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the retrieved model
-     */
-    read(ctx: Ctx | FabricContractContext, key: PrimaryKeyType | string, ...args: any[]): Promise<M | string>;
-    protected getTransientData(ctx: FabricContractContext): any;
-    /**
-     * @description Updates a single model in the state database
-     * @summary Delegates to the repository's update method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {M} model - The model to update
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the updated model
-     */
-    update(context: Ctx | FabricContractContext, model: string | M, ...args: any[]): Promise<string | M>;
-    /**
-     * @description Deletes a single model from the state database
-     * @summary Delegates to the repository's delete method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {string | number} key - The key of the model to delete
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the deleted model
-     */
-    delete(ctx: Ctx | FabricContractContext, key: PrimaryKeyType | string, ...args: any[]): Promise<M | string>;
-    /**
-     * @description Deletes multiple models from the state database
-     * @summary Delegates to the repository's deleteAll method
-     * @param {string[] | number[]} keys - The keys of the models to delete
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the deleted models
-     */
-    deleteAll(ctx: Ctx | FabricContractContext, keys: PrimaryKeyType[] | string, ...args: any[]): Promise<M[] | string>;
-    /**
-     * @description Reads multiple models from the state database
-     * @summary Delegates to the repository's readAll method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {string[] | number[]} keys - The keys of the models to read
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the retrieved models
-     */
-    readAll(ctx: Ctx | FabricContractContext, keys: PrimaryKeyType[] | string, ...args: any[]): Promise<M[] | string>;
-    /**
-     * @description Updates multiple models in the state database
-     * @summary Delegates to the repository's updateAll method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {M[]} models - The models to update
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the updated models
-     */
-    updateAll(context: Ctx | FabricContractContext, models: string | M[], ...args: any[]): Promise<string | M[]>;
-    /**
-     * @description Executes a query with the specified conditions and options.
-     * @summary Provides a simplified way to query the database with common query parameters.
-     * @param {Condition<M>} condition - The condition to filter records.
-     * @param orderBy - The field to order results by.
-     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
-     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
-     * @param {number} [limit] - Optional maximum number of results to return.
-     * @param {number} [skip] - Optional number of results to skip.
-     * @return {Promise<M[]>} The query results as model instances.
-     */
-    query(context: Ctx | FabricContractContext, condition: Condition<M> | string, orderBy: string | keyof M, order?: OrderDirection | string, limit?: number, skip?: number, ...args: any[]): Promise<M[] | string>;
-    /**
-     * @description Executes a raw query against the state database
-     * @summary Delegates to the repository's raw method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {any} rawInput - The query to execute
-     * @param {boolean} docsOnly - Whether to return only documents
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<any>} Promise resolving to the query results
-     */
-    raw(ctx: Ctx | FabricContractContext, rawInput: MangoQuery, docsOnly: boolean, ...args: any[]): Promise<any>;
-    protected serialize(model: M): string;
-    protected deserialize<M extends Model>(str: string): M;
-    protected init(ctx: Ctx | FabricContractContext): Promise<void>;
-    healthcheck(ctx: Ctx | FabricContractContext): Promise<string | healthcheck>;
-    /**
-     * @description Creates multiple models in the state database
-     * @summary Delegates to the repository's createAll method
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @param {M[]} models - The models to create
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the created models
-     */
-    createAll(context: Ctx | FabricContractContext, models: string | M[], ...args: any[]): Promise<string | M[]>;
-    protected ensureMirrorWritePermissions(ctx: FabricContractContext): void;
-    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): Promise<FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>>;
-}

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

@@ -1,2 +0,0 @@
-export * from "./crud-contract";
-export * from "./serialized-crud-contract";

package/lib/types/contracts/crud/serialized-crud-contract.d.ts

@@ -1,42 +0,0 @@
-import { FabricCrudContract } from "./crud-contract";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Context as Ctx } from "fabric-contract-api";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description CRUD contract variant that serializes/deserializes payloads
- * @summary Exposes the same CRUD operations as FabricCrudContract but takes and returns JSON strings to facilitate simple client interactions.
- * @template M - Model type handled by this contract
- * @param {string} name - The contract name
- * @param {Constructor<M>} clazz - The model constructor used to instantiate models from JSON
- * @return {void}
- * @class SerializedCrudContract
- * @example
- * const contract = new SerializedCrudContract<MyModel>('MyModelContract', MyModel);
- * // Client submits JSON string payloads and receives JSON string responses
- */
-export declare class SerializedCrudContract<M extends Model> extends FabricCrudContract<M> {
-    constructor(name: string, clazz: Constructor<M>);
-    create(ctx: Ctx, model: string): Promise<string>;
-    read(ctx: Ctx, key: string): Promise<string>;
-    update(ctx: Ctx, model: string): Promise<string>;
-    delete(ctx: Ctx, key: string): Promise<string>;
-    deleteAll(ctx: Ctx, keys: string): Promise<string>;
-    readAll(ctx: Ctx, keys: string): Promise<string>;
-    updateAll(ctx: Ctx, models: string): Promise<string>;
-    statement(ctx: Ctx, method: string, args: string): Promise<string>;
-    listBy(ctx: Ctx, key: string, order: string): Promise<string>;
-    paginateBy(ctx: Ctx, key: string, order: string, ref: string): Promise<string>;
-    page(ctx: Ctx, value: string, direction: string, ref: string): Promise<string>;
-    findOneBy(ctx: Ctx, key: string, value: string): Promise<string>;
-    query(ctx: Ctx, condition: string, orderBy: string, order: string, limit?: number, skip?: number): Promise<string>;
-    init(ctx: Ctx): Promise<void>;
-    healthcheck(ctx: Ctx): Promise<string>;
-    createAll(context: Ctx, models: string): Promise<string>;
-    countOf(ctx: Ctx, key?: string): Promise<string>;
-    maxOf(ctx: Ctx, key: string): Promise<string>;
-    minOf(ctx: Ctx, key: string): Promise<string>;
-    avgOf(ctx: Ctx, key: string): Promise<string>;
-    sumOf(ctx: Ctx, key: string): Promise<string>;
-    distinctOf(ctx: Ctx, key: string): Promise<string>;
-    groupOf(ctx: Ctx, key: string): Promise<string>;
-}

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

@@ -1,152 +0,0 @@
-import { Context } from "fabric-contract-api";
-import { Allowance, ERC20Token, ERC20Wallet } from "./models";
-import type { FabricContractContext } from "../ContractContext";
-import { FabricCrudContract } from "../crud/crud-contract";
-/**
- * @description ERC20 token contract base for Hyperledger Fabric
- * @summary Implements ERC20-like token logic using repositories and adapters, providing standard token operations such as balance queries, transfers, approvals, minting and burning.
- * @param {string} name - The contract name used to scope token identity
- * @note https://eips.ethereum.org/EIPS/eip-20
- * @return {void}
- * @class FabricERC20Contract
- * @example
- * class MyTokenContract extends FabricERC20Contract {
- *   constructor() { super('MyToken'); }
- * }
- * // The contract exposes methods like Transfer, Approve, Mint, Burn, etc.
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant Contract
- *   participant WalletRepo
- *   participant TokenRepo
- *   participant Ledger
- *   Client->>Contract: Transfer(ctx, to, value)
- *   Contract->>WalletRepo: read(from)
- *   Contract->>WalletRepo: read(to)
- *   Contract->>Ledger: putState(updated balances)
- *   Contract-->>Client: success
- */
-export declare abstract class FabricERC20Contract extends FabricCrudContract<ERC20Wallet> {
-    private walletRepository;
-    private tokenRepository;
-    private allowanceRepository;
-    protected constructor(name: string);
-    TokenName(context: Context): Promise<string>;
-    /**
-     * Return the symbol of the token. E.g. “HIX”.
-     *
-     * @param {Context} context the transaction context
-     * @returns {String} Returns the symbol of the token
-     */
-    Symbol(context: Context): Promise<string>;
-    /**
-     * Return the number of decimals the token uses
-     * e.g. 8, means to divide the token amount by 100000000 to get its user representation.
-     *
-     * @param {Context} context the transaction context
-     * @returns {Number} Returns the number of decimals
-     */
-    Decimals(context: Context): Promise<number>;
-    /**
-     * Return the total token supply.
-     *
-     * @param {Context} context the transaction context
-     * @returns {Number} Returns the total token supply
-     */
-    TotalSupply(context: Context): Promise<number>;
-    /**
-     * BalanceOf returns the balance of the given account.
-     *
-     * @param {Context} ctx the transaction context
-     * @param {String} owner The owner from which the balance will be retrieved
-     * @returns {Number} Returns the account balance
-     */
-    BalanceOf(context: Context, owner: string): Promise<number>;
-    /**
-     * @summary Transfer transfers tokens from client account to recipient account.
-     * @description recipient account must be a valid clientID as returned by the ClientAccountID() function.
-     *
-     * @param {Context} context the transaction context
-     * @param {String} to The recipient
-     * @param {number} value The amount of token to be transferred
-     *
-     * @returns {Boolean} Return whether the transfer was successful or not
-     */
-    Transfer(context: Context, to: string, value: number): Promise<boolean>;
-    /**
-     * Transfer `value` amount of tokens from `from` to `to`.
-     *
-     * @param {Context} context the transaction context
-     * @param {String} from The sender
-     * @param {String} to The recipient
-     * @param {number} value The amount of token to be transferred
-     * @returns {Boolean} Return whether the transfer was successful or not
-     */
-    TransferFrom(context: Context, from: string, to: string, value: number): Promise<boolean>;
-    _transfer(from: string, to: string, value: number, ctx: FabricContractContext): Promise<boolean>;
-    /**
-     * Allows `spender` to spend `value` amount of tokens from the owner. New Approve calls override the previous allowance.
-     * @note https://eips.ethereum.org/EIPS/eip-20
-     *
-     * @param {Context} ctx the transaction context
-     * @param {String} spender The spender
-     * @param {number} value The amount of tokens to be approved for transfer
-     * @returns {Boolean} Return whether the approval was successful or not
-     */
-    Approve(context: Context, spender: string, value: number): Promise<boolean>;
-    /**
-     * Returns the amount of tokens which ` ` is allowed to withdraw from `owner`.
-     *
-     * @param {Context} ctx the transaction context
-     * @param {String} owner The owner of tokens
-     * @param {String} spender The spender who are able to transfer the tokens
-     * @returns {number} Return the amount of remaining tokens allowed to spent
-     */
-    Allowance(context: Context, owner: string, spender: string): Promise<number>;
-    _getAllowance(owner: string, spender: string, ctx: FabricContractContext): Promise<Allowance>;
-    /**
-     * Set optional infomation for a token.
-     *
-     * @param {Context} ctx the transaction context
-     * @param {String} name The name of the token
-     * @param {String} symbol The symbol of the token
-     * @param {String} decimals The decimals of the token
-     * @param {String} totalSupply The totalSupply of the token
-     */
-    Initialize(context: Context, token: ERC20Token): Promise<boolean>;
-    CheckInitialized(context: Context): Promise<void>;
-    /**
-     * Mint creates new tokens and adds them to minter's account balance
-     *
-     * @param {Context} context the transaction context
-     * @param {number} amount amount of tokens to be minted
-     * @returns {Object} The balance
-     */
-    Mint(context: Context, amount: number): Promise<void>;
-    /**
-     * Burn redeem tokens from minter's account balance
-     *
-     * @param {Context} context the transaction context
-     * @param {number} amount amount of tokens to be burned
-     * @returns {Object} The balance
-     */
-    Burn(context: Context, amount: number): Promise<void>;
-    /**
-     * BurnFrom redeem tokens from account allowence and balance
-     *
-     * @param {Context} context the transaction context
-     * @param {number} account account from where tokens will be burned
-     * @param {number} amount amount of tokens to be burned
-     * @returns {Object} The balance
-     */
-    BurnFrom(context: Context, account: string, amount: number): Promise<void>;
-    /**
-     * ClientAccountBalance returns the balance of the requesting client's account.
-     *
-     * @param {Context} context the transaction context
-     * @returns {Number} Returns the account balance
-     */
-    ClientAccountBalance(context: Context): Promise<number>;
-    ClientAccountID(context: Context): Promise<string>;
-}

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

@@ -1,2 +0,0 @@
-export * from "../FabricContractStatement";
-export declare const contracts: any[];