@codex-ts/core-lib 1.1.5 → 2.0.0

package/lib/models/workflow.model.d.ts

@@ -0,0 +1,27 @@
+import { BaseEntity } from './base.entity.model';
+import { BaseComment } from './base.comment.model';
+/**
+ * @deprecated Models `io.codex.library.core.task.WorkflowDto`, which paired with
+ * `microservice-starter-lib`'s Spring-State-Machine-based `BaseWorkflowController`. That
+ * controller was deleted (see `WORKFLOW_ENGINE_MIGRATION.md`) in favor of `workflow-engine-lib`,
+ * a completely different engine with its own REST API and its own Angular client — see
+ * `WorkflowTask`/`WorkflowInstance`/`WorkflowEngineApiService` in `workflow-engine/`. Nothing in
+ * this codebase serves the endpoints this interface's shape assumes; kept only for source
+ * compatibility with any existing consumer, not as a working feature.
+ */
+export interface Workflow<S = string, C = BaseComment> extends BaseEntity {
+    status: S;
+    comments: C[];
+    currentAssignee: string;
+    currentAssigneeName: string;
+    currentDepartment: string;
+    currentSegment: string;
+    previousAssignee: string;
+    previousAssigneeName: string;
+    statusChangedDate: Date;
+    statusChangedBy: string;
+    workflowType: string;
+    currentWorkflowStep: string;
+    workflowVersion: number;
+    requiresApproval: boolean;
+}

package/lib/services/base-entity.service.d.ts

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+import { HttpUtilityService } from './http-utility.service';
+import { UtilsService } from './utils.service';
+import { MessageService } from 'primeng/api';
+import { Page } from '../models/pagination/page.interface';
+import { PageRequest } from '../models/pagination/page-request.interface';
+import { EntityService } from './entity-service.interface';
+import { ReferenceDto } from '../models/reference-dto.interface';
+import { BaseModel } from '../models/base.model';
+export declare abstract class BaseEntityService<T extends BaseModel> implements EntityService<T> {
+    protected httpUtility: HttpUtilityService;
+    protected utilsService: UtilsService;
+    protected resourcePath: string;
+    protected backendBaseUrl: string;
+    protected messageService: MessageService | undefined;
+    get loading$(): Observable<boolean>;
+    protected apiUrl: string;
+    /**
+     * Creates an instance of BaseCrudService.
+     * @param httpUtility - Service for making HTTP requests
+     * @param utilsService - Utility service for common operations
+     * @param resourcePath - API resource path (e.g., 'customers', 'products')
+     * @param backendBaseUrl - Base URL for the backend API
+     * @param messageService - Optional service for showing messages
+     */
+    protected constructor(httpUtility: HttpUtilityService, utilsService: UtilsService, resourcePath: string, backendBaseUrl: string, messageService: MessageService | undefined);
+    /**
+     * Find entities by createdBy with pagination using PageRequest and filters.
+     * POST /page with { ...pageRequest, filters: [{ field: 'createdBy', value: createdBy }] }
+     */
+    findByCreatedBy(createdBy: string, pageRequest?: PageRequest): Observable<Page<T>>;
+    /**
+     * Get all entities with pagination.
+     * POST /page with pageRequest
+     */
+    getAll(pageRequest?: PageRequest): Observable<Page<T>>;
+    /**
+     * Joins URL parts ensuring no double slashes
+     */
+    private joinUrls;
+    getById(uuid: string): Observable<T>;
+    create(entity: Omit<T, 'uuid'>): Observable<T>;
+    update(uuid: string, entity: Omit<T, 'uuid'>): Observable<T>;
+    delete(uuid: string): Observable<void>;
+    /**
+     * Get all entities without pagination.
+     * GET /
+     */
+    findAll(): Observable<T[]>;
+    /**
+     * Get detailed entity information by UUID.
+     * GET /{uuid}/detailed
+     */
+    findDetailedByUuid(uuid: string): Observable<T>;
+    /**
+     * Partially update an entity with the specified field values.
+     * PATCH /{uuid}
+     */
+    patch(uuid: string, updates: Partial<T>): Observable<T>;
+    /**
+     * Get all entities as reference data.
+     * GET /reference
+     */
+    findAllReference(): Observable<ReferenceDto[]>;
+    /**
+     * Get paginated reference data.
+     * POST /reference/page
+     */
+    findAllReferencePaginated(pageRequest?: PageRequest): Observable<Page<ReferenceDto>>;
+    /**
+     * Get all entities with filters (non-paginated).
+     * GET /search?field=value&...
+     */
+    findAllWithFilters(filters: Record<string, string>): Observable<T[]>;
+    /**
+     * Get a single entity by filters (non-paginated).
+     * GET /search-one?field=value&...
+     */
+    findOneWithFilters(filters: Record<string, string>): Observable<T | null>;
+}

package/lib/services/base-error.service.d.ts

@@ -0,0 +1,24 @@
+import { InjectionToken, Signal } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export interface ErrorState {
+    type: string;
+    message: string;
+    code?: string | number;
+    [key: string]: any;
+}
+export declare class BaseErrorService {
+    private readonly _error;
+    private readonly router;
+    private readonly messageService;
+    get error(): Signal<ErrorState | null>;
+    /**
+     * Handle HTTP and other errors in the application
+     */
+    handleError(error: HttpErrorResponse | Error): void;
+    setError(error: ErrorState): void;
+    clearError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseErrorService>;
+}
+export declare const ERROR_SERVICE: InjectionToken<BaseErrorService>;

package/lib/services/base-task.service.d.ts

@@ -3,38 +3,40 @@ import { HttpUtilityService } from './http-utility.service';
 import { UtilsService } from './utils.service';
 import { MessageService } from 'primeng/api';
 import { Page } from '../models/pagination/page.interface';
-import { PageRequest } from '../models/pagination/page-request.interface';
-import { BaseCrudService } from './base-crud.service';
+import { BaseEntityService } from './base-entity.service';
+import { KeycloakService } from '../keycloak/keycloak.service';
+import { BaseTask } from '../models/base-task.model';
+import { TaskEntityService } from './task-entity-service.interface';
 import * as i0 from "@angular/core";
 /**
  * Base service for task-related operations that extends the BaseCrudService.
  * Implements endpoints defined in Java BaseTaskController.
+ *
+ * @deprecated `BaseTaskController` (the Java controller this service's `sendEvent`/`PUT
+ * /{uuid}/event/{event}` call targets) no longer exists — it was deleted along with
+ * `microservice-starter-lib`'s Spring-State-Machine-based workflow subsystem in favor of
+ * `workflow-engine-lib`. Calling `sendEvent` against any current backend will 404. Use
+ * `WorkflowEngineApiService` from `workflow-engine/` instead, which targets the actual current
+ * engine API (`claim`/`unclaim`/`start`/`complete`/`reject`/`reassign` on `/workflow/tasks`).
  */
-export declare abstract class BaseTaskService<T extends {
-    uuid: string;
-}> extends BaseCrudService<T> {
+export declare abstract class BaseTaskService<T extends BaseTask, AU = any, S extends string = string, E extends string = string> extends BaseEntityService<T> implements TaskEntityService<T, S, E> {
     protected httpUtility: HttpUtilityService;
     protected utilsService: UtilsService;
     protected resourcePath: string;
     protected backendBaseUrl: string;
     protected messageService: MessageService | undefined;
-    constructor(httpUtility: HttpUtilityService, utilsService: UtilsService, resourcePath: string, backendBaseUrl: string, messageService: MessageService | undefined);
-    /**
-     * Find tasks by department with pagination
-     * Maps to GET /department/{department} endpoint
-     */
-    findByDepartment(department: string, pageRequest?: PageRequest): Observable<Page<T>>;
-    /**
-     * Find tasks by assigned user with pagination
-     * Maps to GET /user/{userId} endpoint
-     */
-    findByAssignedUser(userId: string, pageRequest?: PageRequest): Observable<Page<T>>;
+    readonly keycloakService: KeycloakService;
+    constructor(httpUtility: HttpUtilityService, utilsService: UtilsService, resourcePath: string, backendBaseUrl: string, messageService: MessageService | undefined, keycloakService: KeycloakService);
     /**
      * Send an event for a task
      * Maps to PUT /{uuid}/event/{event} endpoint
      * For ASSIGN events, userId and department are required
      */
-    sendEvent(uuid: string, event: string, userId?: string, department?: string): Observable<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTaskService<any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BaseTaskService<any>>;
+    sendEvent(uuid: string, event: E, userId?: string, department?: string): Observable<T>;
+    /**
+     * Calls POST /current-assignees-in endpoint to fetch tasks by assignees with pagination.
+     */
+    getByCurrentAssigneesIn(assigneeIds: string[], pageable?: any): Observable<Page<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTaskService<any, any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseTaskService<any, any, any, any>>;
 }

package/lib/services/entity-registry.service.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { HttpUtilityService } from './http-utility.service';
+import { ReferenceDataProviderService } from './reference-data-provider.service';
+import * as i0 from "@angular/core";
+export declare class EntityRegistryService {
+    private httpUtility;
+    private dataProvider;
+    constructor(httpUtility: HttpUtilityService, dataProvider: ReferenceDataProviderService);
+    /**
+     * Gets reference options for an entity, suitable for select/dropdown components
+     * @param entityName The name of the entity (e.g., 'customers', 'departments')
+     * @returns Observable of options array with label/value pairs
+     */
+    getEntityOptions(entityName: string): Observable<{
+        label: string;
+        value: string;
+        data?: any;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityRegistryService>;
+}

package/lib/services/entity-service.interface.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { Page } from '../models/pagination/page.interface';
+import { PageRequest } from '../models/pagination/page-request.interface';
+import { ReferenceDto } from '../models/reference-dto.interface';
+import { BaseModel } from '../models/base.model';
+/**
+ * Base interface for CRUD operations that all entity services must implement
+ * @template T - The entity type
+ */
+export interface EntityService<T extends BaseModel> {
+    create(data: Omit<T, 'uuid'>): Observable<T>;
+    update(uuid: string, data: Omit<T, 'uuid'>): Observable<T>;
+    delete(uuid: string): Observable<void>;
+    getById(uuid: string): Observable<T>;
+    getAll(pageRequest?: PageRequest): Observable<Page<T>>;
+    findAll(): Observable<T[]>;
+    findAllReference(): Observable<ReferenceDto[]>;
+    findAllReferencePaginated(pageRequest?: PageRequest): Observable<Page<ReferenceDto>>;
+    findByCreatedBy(createdBy: string, pageRequest?: PageRequest): Observable<Page<T>>;
+    patch(uuid: string, updates: Partial<T>): Observable<T>;
+    findDetailedByUuid(uuid: string): Observable<T>;
+}

package/lib/services/form.service.d.ts

@@ -1,20 +1,22 @@
 import { Observable } from 'rxjs';
 import { PageMode } from '../constants/app.constants';
 import { FormComponentState } from '../states/form-component.state';
-import { EntityService } from './entity.service';
+import { EntityService } from './entity-service.interface';
 import { FormlyConfigService } from './formly-config.service';
 import { NotificationService } from './notification.service';
-export declare class FormService<T extends {
-    uuid: string;
-}> {
+import { BaseModel } from '../models/base.model';
+export declare class FormService<T extends BaseModel> {
     private entityService;
     private formlyConfigService;
     private notificationService;
     private entityName;
     private jsonFields;
     private dropdownOptions;
-    protected formState: FormComponentState<T>;
+    formState: FormComponentState<T>;
     constructor(entityService: EntityService<T>, formlyConfigService: FormlyConfigService, notificationService: NotificationService, entityName: string, jsonFields: any, dropdownOptions?: Record<string, any>);
+    private handleFormChange;
+    private updateState;
+    private calculateHasChanges;
     private initializeForm;
     private getFormlyFieldConfig;
     loadData(uuid?: string): Observable<void>;
@@ -25,7 +27,4 @@ export declare class FormService<T extends {
     setMode(mode: PageMode): void;
     getState(): FormComponentState<T>;
     patchValue(value: Partial<T>): void;
-    private updateCurrentData;
-    private checkFormChanges;
-    private hasFormChanges;
 }

package/lib/services/http-utility.service.d.ts

@@ -16,7 +16,10 @@ export declare class HttpUtilityService {
     private messageService?;
     private loading;
     loading$: Observable<boolean>;
+    private inFlight;
     constructor(http: HttpClient, messageService?: MessageService | undefined);
+    private startLoading;
+    private endLoading;
     /**
      * Perform a GET request with enhanced options
      * @param url The endpoint URL
@@ -61,6 +64,21 @@ export declare class HttpUtilityService {
         retries?: number;
         timeoutMs?: number;
     }): Observable<T>;
+    /**
+     * Perform a PATCH request with enhanced options
+     * @param url The endpoint URL
+     * @param body The request payload
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    patch<T>(url: string, body: any, options?: {
+        params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        responseType?: 'json';
+        withCredentials?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+    }): Observable<T>;
     /**
      * Perform a DELETE request with enhanced options
      * @param url The endpoint URL

package/lib/services/master-data-service.interface.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+import { IDepartment } from '../models/department.interface';
+export interface MasterDataService {
+    getDepartments(): Observable<IDepartment[]>;
+}

package/lib/services/task-entity-service.interface.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from "rxjs";
+import { EntityService } from "./entity-service.interface";
+import { BaseTask } from "../models/base-task.model";
+/**
+ * Interface for task-specific operations
+ * @template T - The entity type (must extend BaseTaskModel)
+ * @template S - The status enum type (for task status)
+ * @template E - The event enum type (for task events)
+ *
+ * @deprecated Paired with {@link BaseTaskService}, which targets a Java controller that no
+ * longer exists — see that class's `@deprecated` note. Use `WorkflowEngineApiService` instead.
+ */
+export interface TaskEntityService<T extends BaseTask, S extends string = string, E extends string = string> extends EntityService<T> {
+    /**
+     * Send an event for a task.
+     * Maps to PUT /{uuid}/event/{event} endpoint.
+     * For ASSIGN events, userId and department are required.
+     * @param uuid The task UUID.
+     * @param event The event enum value.
+     * @param userId Optional user ID for assignment.
+     * @param department Optional department for assignment.
+     */
+    sendEvent(uuid: string, event: E, userId?: string, department?: string): Observable<T>;
+}

package/lib/validators/common-validators.d.ts

@@ -0,0 +1,61 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+/**
+ * Common Validators for form fields
+ */
+export declare class CommonValidators {
+    /**
+     * Email validator pattern
+     * Matches standard email format with @ and domain
+     */
+    static readonly EMAIL_PATTERN: RegExp;
+    /**
+     * Indian mobile number validator pattern
+     * Matches 10-digit numbers, optionally starting with +91 or 0
+     */
+    static readonly MOBILE_PATTERN: RegExp;
+    /**
+     * PAN card validator pattern
+     * Format: AAAAA0000A (5 letters, 4 numbers, 1 letter)
+     */
+    static readonly PAN_PATTERN: RegExp;
+    /**
+     * Returns a validator function to check if the value matches the given pattern
+     * @param pattern - Regular expression to test
+     * @param errorMessage - Optional custom error message
+     */
+    static patternValidator(pattern: RegExp, errorMessage?: string): ValidatorFn;
+    /**
+     * Email validator function
+     */
+    static email(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Mobile number validator function
+     */
+    static mobileNumber(control: AbstractControl): ValidationErrors | null;
+    /**
+     * PAN card validator function
+     */
+    static panCard(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Generate formly validator configuration for email
+     */
+    static formlyEmailValidator(): {
+        expression: (fc: AbstractControl) => boolean;
+        message: (error: any, field: FormlyFieldConfig) => string;
+    };
+    /**
+     * Generate formly validator configuration for mobile number
+     */
+    static formlyMobileValidator(): {
+        expression: (fc: AbstractControl) => boolean;
+        message: (error: any, field: FormlyFieldConfig) => string;
+    };
+    /**
+     * Generate formly validator configuration for PAN card
+     */
+    static formlyPanValidator(): {
+        expression: (fc: AbstractControl) => boolean;
+        message: (error: any, field: FormlyFieldConfig) => string;
+    };
+}

package/lib/workflow-engine/workflow-engine-api.service.d.ts

@@ -0,0 +1,104 @@
+import { Observable } from 'rxjs';
+import { MessageService } from 'primeng/api';
+import { HttpUtilityService } from '../services/http-utility.service';
+import { UtilsService } from '../services/utils.service';
+import { BusinessObject, CancelInstanceRequest, CompleteTaskRequest, DeployWorkflowRequest, QueueSearchCriteria, QueueView, ReassignTaskRequest, RegisterBusinessObjectRequest, RegisterFormRequest, SetVariablesRequest, SignalEventRequest, StartInstanceRequest, WorkflowAuditEntry, WorkflowDefinitionSummary, WorkflowForm, WorkflowInstance, WorkflowPage, WorkflowTask, WorkflowVersionDetail, WorkflowVersionSummary } from './workflow-engine.models';
+/**
+ * Client for `workflow-engine-lib`'s REST API — the data-driven engine that replaced
+ * `microservice-starter-lib`'s Spring-State-Machine-based workflow subsystem.
+ *
+ * Follows this library's established DI convention (see {@link BaseEntityService}): not
+ * `providedIn: 'root'`, constructed with the backend base URL by the consuming application —
+ * *
+ * ```ts
+ * providers: [{
+ *   provide: WorkflowEngineApiService,
+ *   useFactory: (http: HttpUtilityService, utils: UtilsService, msg: MessageService) =>
+ *     new WorkflowEngineApiService(http, utils, 'https://api.example.com/workflow', msg),
+ *   deps: [HttpUtilityService, UtilsService, MessageService],
+ * }]
+ * ```
+ *
+ * Every method maps one-to-one onto an engine endpoint; nothing here is business-specific.
+ *
+ * Deliberately not decorated with {@code @Injectable()} — like {@link BaseEntityService}, this
+ * class is always provided via an explicit `useFactory`/`useClass` provider (see above), never
+ * auto-constructed by Angular's injector, so its constructor isn't required to be fully
+ * DI-resolvable (`backendBaseUrl: string` isn't a valid injection token on its own).
+ */
+export declare class WorkflowEngineApiService {
+    protected httpUtility: HttpUtilityService;
+    protected utilsService: UtilsService;
+    protected backendBaseUrl: string;
+    protected messageService: MessageService | undefined;
+    protected apiUrl: string;
+    /**
+     * Creates the client.
+     *
+     * @param httpUtility     HTTP requests, loading state, standardised error handling
+     * @param utilsService    UUID validation
+     * @param backendBaseUrl  base URL of the service hosting `workflow-engine-lib`, e.g.
+     *                        `https://api.example.com/workflow`
+     * @param messageService  optional, shown on client-side validation failures
+     */
+    constructor(httpUtility: HttpUtilityService, utilsService: UtilsService, backendBaseUrl: string, messageService: MessageService | undefined);
+    private requireUuid;
+    /** Finds a task by id. `GET /tasks/{id}` */
+    getTask(id: string): Observable<WorkflowTask>;
+    /** Claims a task out of a shared queue. `POST /tasks/{id}/claim` */
+    claimTask(id: string): Observable<WorkflowTask>;
+    /** Releases a claim, returning the task to its queue. `POST /tasks/{id}/unclaim` */
+    unclaimTask(id: string): Observable<WorkflowTask>;
+    /** Marks work on a task as actively started. `POST /tasks/{id}/start` */
+    startTask(id: string): Observable<WorkflowTask>;
+    /** Completes a task and resumes its workflow. `POST /tasks/{id}/complete` */
+    completeTask(id: string, request?: CompleteTaskRequest): Observable<WorkflowTask>;
+    /** Rejects a task, resuming its workflow down a different path. `POST /tasks/{id}/reject` */
+    rejectTask(id: string, request?: CompleteTaskRequest): Observable<WorkflowTask>;
+    /** Reassigns a task to a different subject. `POST /tasks/{id}/reassign` */
+    reassignTask(id: string, request: ReassignTaskRequest): Observable<WorkflowTask>;
+    /** Starts a new workflow instance. `POST /instances` */
+    startInstance(request: StartInstanceRequest): Observable<WorkflowInstance>;
+    /** Finds an instance by id. `GET /instances/{id}` */
+    getInstance(id: string): Observable<WorkflowInstance>;
+    /** Finds instances by business key. `GET /instances?businessKey=...` */
+    findInstancesByBusinessKey(businessKey: string): Observable<WorkflowInstance[]>;
+    /** Loads an instance's audit history, oldest first. `GET /instances/{id}/history` */
+    instanceHistory(id: string): Observable<WorkflowAuditEntry[]>;
+    /** Reads an instance's current variables. `GET /instances/{id}/variables` */
+    getInstanceVariables(id: string): Observable<Record<string, unknown>>;
+    /** Sets or replaces instance variables outside of any node execution. `PUT /instances/{id}/variables` */
+    setInstanceVariables(id: string, request: SetVariablesRequest): Observable<WorkflowInstance>;
+    /** Signals an external event to a waiting instance. `POST /instances/{id}/signal` */
+    signalInstance(id: string, request: SignalEventRequest): Observable<WorkflowInstance>;
+    /** Cancels a running instance and withdraws its open tasks. `POST /instances/{id}/cancel` */
+    cancelInstance(id: string, request?: CancelInstanceRequest): Observable<WorkflowInstance>;
+    /** Deploys a workflow definition, creating a new immutable version. `POST /definitions` */
+    deployDefinition(request: DeployWorkflowRequest): Observable<WorkflowVersionSummary>;
+    /** Lists every workflow definition. `GET /definitions` */
+    listDefinitions(): Observable<WorkflowDefinitionSummary[]>;
+    /** Finds a definition by key. `GET /definitions/{key}` */
+    getDefinition(key: string): Observable<WorkflowDefinitionSummary>;
+    /** Lists every deployed version of a definition. `GET /definitions/{key}/versions` */
+    listVersions(key: string): Observable<WorkflowVersionSummary[]>;
+    /** Loads the active version's authored document. `GET /definitions/{key}/versions/active` */
+    activeVersion(key: string): Observable<WorkflowVersionDetail>;
+    /** Activates a specific version. `POST /definitions/{key}/versions/{versionNumber}/activate` */
+    activateVersion(key: string, versionNumber: number): Observable<WorkflowVersionSummary>;
+    /** Loads one of the queue views. `GET /queue/{view}` */
+    queue(view: QueueView, page?: number, size?: number): Observable<WorkflowPage<WorkflowTask>>;
+    /** Searches the queue with structured criteria. `POST /queue/search` */
+    searchQueue(criteria?: QueueSearchCriteria, page?: number, size?: number): Observable<WorkflowPage<WorkflowTask>>;
+    /** Registers a business object type, or updates one with the same code. `POST /business-objects` */
+    registerBusinessObject(request: RegisterBusinessObjectRequest): Observable<BusinessObject>;
+    /** Lists every registered business object. `GET /business-objects` */
+    listBusinessObjects(): Observable<BusinessObject[]>;
+    /** Finds one business object, including the workflows bound to it. `GET /business-objects/{code}` */
+    getBusinessObject(code: string): Observable<BusinessObject>;
+    /** Registers a new version of a form under a business object. `POST /business-objects/{code}/forms` */
+    registerForm(code: string, request: RegisterFormRequest): Observable<WorkflowForm>;
+    /** Lists every form registered under a business object. `GET /business-objects/{code}/forms` */
+    listForms(code: string): Observable<WorkflowForm[]>;
+    /** Finds the active form version a new task would render. `GET /business-objects/{code}/forms/{formKey}` */
+    activeForm(code: string, formKey: string): Observable<WorkflowForm>;
+}