@masterteam/governance 0.0.1

package/types/masterteam-governance.d.ts

@@ -0,0 +1,443 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef, OnInit } from '@angular/core';
+import { TableAction, ColumnDef, CellChangeEvent } from '@masterteam/components/table';
+import { ModalService } from '@masterteam/components/modal';
+import * as _masterteam_governance from '@masterteam/governance';
+import { FormControl } from '@angular/forms';
+import { ModalRef } from '@masterteam/components/dialog';
+import * as _masterteam_components from '@masterteam/components';
+import { CrudStateBase, DynamicFormConfig } from '@masterteam/components';
+import * as rxjs from 'rxjs';
+import { StateContext } from '@ngxs/store';
+
+interface LoadingStateShape<L extends string = string> {
+    loadingActive: L[];
+    errors: Partial<Record<L, string>>;
+}
+
+interface Translatable {
+    en: string;
+    ar: string;
+}
+declare enum GovernanceRuleTypeEnum {
+    ModuleExists = 1,
+    ModuleDoesNotExist = 2,
+    ModuleMaxCount = 3,
+    ModuleMinCount = 4,
+    FieldRequired = 5,
+    FieldValue = 6,
+    PhaseGateModuleRequired = 7,
+    NoActiveRequest = 8
+}
+/**
+ * Option for select/multi-select fields
+ */
+interface ConfigurationFieldOption {
+    label: string;
+    value: string;
+}
+/**
+ * Options source indicator for select fields
+ * - 'auto-populated': Options already in response (modules, phase gates, statuses)
+ * - 'static': Hardcoded options in response
+ * - 'requestSchema': Fetch from request schema endpoint
+ * - 'properties': Fetch from properties endpoint
+ * - null/undefined: No options needed (text/number fields)
+ */
+type OptionsSource = 'auto-populated' | 'static' | 'requestSchema' | 'properties' | null;
+/**
+ * Configuration field schema - now array-based with key property
+ */
+interface ConfigurationFieldSchema {
+    key: string;
+    type: 'text' | 'textarea' | 'number' | 'select' | 'multi-select' | 'checkbox' | 'date';
+    label: Translatable;
+    required?: boolean;
+    defaultValue?: any;
+    min?: number;
+    max?: number;
+    options?: ConfigurationFieldOption[];
+    optionsSource?: OptionsSource;
+    colSpan?: number;
+}
+interface GovernanceRuleType {
+    type: string;
+    key: string;
+    name: Translatable;
+    description: Translatable;
+    supportedScopes: string[];
+    supportedOperations: string[];
+    configurationSchema: ConfigurationFieldSchema[];
+}
+interface GovernanceRule {
+    id: number;
+    key: string;
+    name: Translatable;
+    description?: Translatable;
+    errorMessage: Translatable;
+    ruleType: GovernanceRuleTypeEnum;
+    ruleTypeKey: string;
+    targetScope: string;
+    targetModuleKey?: string;
+    targetOperationKey?: string;
+    levelId: number;
+    configuration: Record<string, any>;
+    priority: number;
+    isActive: boolean;
+    stopOnFailure: boolean;
+    createdAt: string;
+    createdBy?: string;
+    modifiedAt?: string;
+    modifiedBy?: string;
+}
+interface CreateGovernanceRuleDto {
+    key: string;
+    name: Record<string, string>;
+    description?: Record<string, string>;
+    errorMessage: Record<string, string>;
+    ruleType: string;
+    targetScope: string;
+    targetModuleKey?: string;
+    targetOperationKey?: string;
+    configuration?: Record<string, any>;
+    priority: number;
+    stopOnFailure: boolean;
+}
+interface UpdateGovernanceRuleDto extends CreateGovernanceRuleDto {
+    isActive: boolean;
+}
+interface GovernanceViolation {
+    ruleKey: string;
+    message: string;
+    details?: any;
+}
+interface GovernanceViolationError {
+    type: 'GovernanceViolation';
+    title: string;
+    status: 403;
+    violations: GovernanceViolation[];
+}
+interface GovernanceModule {
+    id: string;
+    key: string;
+    name: Translatable;
+    isActive: boolean;
+}
+declare enum GovernanceActionKey {
+    GetRules = "getRules",
+    GetRule = "getRule",
+    GetRuleTypes = "getRuleTypes",
+    AddRule = "addRule",
+    UpdateRule = "updateRule",
+    DeleteRule = "deleteRule",
+    ToggleRuleActive = "toggleRuleActive",
+    GetModules = "getModules",
+    GetRequestSchemas = "getRequestSchemas",
+    GetProperties = "getProperties"
+}
+interface GovernanceRequestSchema {
+    id: number;
+    name: Translatable;
+    isPublished: boolean;
+}
+interface GovernanceProperty {
+    id: number;
+    key: string;
+    name: Translatable;
+}
+interface GovernanceStateModel extends LoadingStateShape<GovernanceActionKey> {
+    levelId: number | null;
+    rules: GovernanceRule[];
+    ruleTypes: GovernanceRuleType[];
+    selectedRule: GovernanceRule | null;
+    modules: GovernanceModule[];
+    requestSchemas: GovernanceRequestSchema[];
+    properties: GovernanceProperty[];
+}
+
+declare class SetLevelId {
+    levelId: number;
+    static readonly type = "[Governance] Set Level ID";
+    constructor(levelId: number);
+}
+declare class GetGovernanceRules {
+    static readonly type = "[Governance] Get Rules";
+}
+declare class GetGovernanceRule {
+    id: number;
+    static readonly type = "[Governance] Get Rule";
+    constructor(id: number);
+}
+declare class GetGovernanceRuleTypes {
+    static readonly type = "[Governance] Get Rule Types";
+}
+declare class AddGovernanceRule {
+    rule: CreateGovernanceRuleDto;
+    static readonly type = "[Governance] Add Rule";
+    constructor(rule: CreateGovernanceRuleDto);
+}
+declare class UpdateGovernanceRule {
+    id: number;
+    rule: UpdateGovernanceRuleDto;
+    static readonly type = "[Governance] Update Rule";
+    constructor(id: number, rule: UpdateGovernanceRuleDto);
+}
+declare class DeleteGovernanceRule {
+    id: number;
+    static readonly type = "[Governance] Delete Rule";
+    constructor(id: number);
+}
+declare class ToggleGovernanceRuleActive {
+    id: number;
+    static readonly type = "[Governance] Toggle Rule Active";
+    constructor(id: number);
+}
+declare class ClearSelectedRule {
+    static readonly type = "[Governance] Clear Selected Rule";
+}
+declare class ResetGovernanceState {
+    static readonly type = "[Governance] Reset State";
+}
+declare class GetModules {
+    static readonly type = "[Governance] Get Modules";
+}
+/**
+ * Get request schemas for a specific scope
+ * @param targetScope - 'Level' or 'Module'
+ * @param targetModuleKey - Required if scope is 'Module'
+ */
+declare class GetRequestSchemas {
+    targetScope: string;
+    targetModuleKey?: string | undefined;
+    static readonly type = "[Governance] Get Request Schemas";
+    constructor(targetScope: string, targetModuleKey?: string | undefined);
+}
+/**
+ * Get properties for a specific scope
+ * @param targetScope - 'Level' or 'Module'
+ * @param targetModuleKey - Required if scope is 'Module'
+ */
+declare class GetProperties {
+    targetScope: string;
+    targetModuleKey?: string | undefined;
+    static readonly type = "[Governance] Get Properties";
+    constructor(targetScope: string, targetModuleKey?: string | undefined);
+}
+/**
+ * Clear request schemas (when scope/module changes)
+ */
+declare class ClearRequestSchemas {
+    static readonly type = "[Governance] Clear Request Schemas";
+}
+/**
+ * Clear properties (when scope/module changes)
+ */
+declare class ClearProperties {
+    static readonly type = "[Governance] Clear Properties";
+}
+
+declare class GovernanceFacade {
+    private readonly store;
+    readonly levelId: _angular_core.Signal<number | null>;
+    readonly rules: _angular_core.Signal<_masterteam_governance.GovernanceRule[]>;
+    readonly ruleTypes: _angular_core.Signal<_masterteam_governance.GovernanceRuleType[]>;
+    readonly selectedRule: _angular_core.Signal<_masterteam_governance.GovernanceRule | null>;
+    readonly modules: _angular_core.Signal<_masterteam_governance.GovernanceModule[]>;
+    readonly requestSchemas: _angular_core.Signal<_masterteam_governance.GovernanceRequestSchema[]>;
+    readonly properties: _angular_core.Signal<_masterteam_governance.GovernanceProperty[]>;
+    private readonly loadingActive;
+    private readonly errors;
+    readonly isLoadingRules: _angular_core.Signal<boolean>;
+    readonly isLoadingRule: _angular_core.Signal<boolean>;
+    readonly isLoadingRuleTypes: _angular_core.Signal<boolean>;
+    readonly isAddingRule: _angular_core.Signal<boolean>;
+    readonly isUpdatingRule: _angular_core.Signal<boolean>;
+    readonly isDeletingRule: _angular_core.Signal<boolean>;
+    readonly isTogglingRule: _angular_core.Signal<boolean>;
+    readonly isLoadingModules: _angular_core.Signal<boolean>;
+    readonly isLoadingRequestSchemas: _angular_core.Signal<boolean>;
+    readonly isLoadingProperties: _angular_core.Signal<boolean>;
+    readonly rulesError: _angular_core.Signal<string | null>;
+    readonly ruleError: _angular_core.Signal<string | null>;
+    readonly ruleTypesError: _angular_core.Signal<string | null>;
+    readonly addRuleError: _angular_core.Signal<string | null>;
+    readonly updateRuleError: _angular_core.Signal<string | null>;
+    readonly deleteRuleError: _angular_core.Signal<string | null>;
+    readonly modulesError: _angular_core.Signal<string | null>;
+    readonly requestSchemasError: _angular_core.Signal<string | null>;
+    readonly propertiesError: _angular_core.Signal<string | null>;
+    readonly activeRules: _angular_core.Signal<_masterteam_governance.GovernanceRule[]>;
+    readonly inactiveRules: _angular_core.Signal<_masterteam_governance.GovernanceRule[]>;
+    readonly rulesCount: _angular_core.Signal<number>;
+    setLevelId(levelId: number): rxjs.Observable<void>;
+    getRules(): rxjs.Observable<void>;
+    getRule(id: number): rxjs.Observable<void>;
+    getRuleTypes(): rxjs.Observable<void>;
+    getModules(): rxjs.Observable<void>;
+    addRule(rule: CreateGovernanceRuleDto): rxjs.Observable<void>;
+    updateRule(id: number, rule: UpdateGovernanceRuleDto): rxjs.Observable<void>;
+    deleteRule(id: number): rxjs.Observable<void>;
+    toggleRuleActive(id: number): rxjs.Observable<void>;
+    clearSelectedRule(): rxjs.Observable<void>;
+    resetState(): rxjs.Observable<void>;
+    getRequestSchemas(targetScope: string, targetModuleKey?: string): rxjs.Observable<void>;
+    getProperties(targetScope: string, targetModuleKey?: string): rxjs.Observable<void>;
+    clearRequestSchemas(): rxjs.Observable<void>;
+    clearProperties(): rxjs.Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GovernanceFacade, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GovernanceFacade>;
+}
+
+interface Response<T> {
+    endpoint: string;
+    status: number;
+    code: number;
+    locale: string;
+    message?: string | null;
+    errors?: any | null;
+    data: T;
+    cacheSession?: string;
+}
+
+declare class GovernanceState extends CrudStateBase<GovernanceRule, GovernanceStateModel, GovernanceActionKey> {
+    private http;
+    static getLevelId(state: GovernanceStateModel): number | null;
+    static getRules(state: GovernanceStateModel): GovernanceRule[];
+    static getRuleTypes(state: GovernanceStateModel): GovernanceRuleType[];
+    static getSelectedRule(state: GovernanceStateModel): GovernanceRule | null;
+    static getModules(state: GovernanceStateModel): GovernanceModule[];
+    static getRequestSchemas(state: GovernanceStateModel): GovernanceRequestSchema[];
+    static getProperties(state: GovernanceStateModel): GovernanceProperty[];
+    static getLoadingActive(state: GovernanceStateModel): string[];
+    static getErrors(state: GovernanceStateModel): Record<string, string | null>;
+    setLevelId(ctx: StateContext<GovernanceStateModel>, { levelId }: SetLevelId): void;
+    resetState(ctx: StateContext<GovernanceStateModel>): void;
+    getRules(ctx: StateContext<GovernanceStateModel>): rxjs.Observable<Response<GovernanceRule[]>> | undefined;
+    getRule(ctx: StateContext<GovernanceStateModel>, { id }: GetGovernanceRule): rxjs.Observable<Response<GovernanceRule>> | undefined;
+    getRuleTypes(ctx: StateContext<GovernanceStateModel>): rxjs.Observable<Response<GovernanceRuleType[]>>;
+    addRule(ctx: StateContext<GovernanceStateModel>, { rule }: AddGovernanceRule): rxjs.Observable<_masterteam_components.Response<GovernanceRule>> | undefined;
+    updateRule(ctx: StateContext<GovernanceStateModel>, { id, rule }: UpdateGovernanceRule): rxjs.Observable<_masterteam_components.Response<GovernanceRule>> | undefined;
+    deleteRule(ctx: StateContext<GovernanceStateModel>, { id }: DeleteGovernanceRule): rxjs.Observable<_masterteam_components.Response<void>> | undefined;
+    toggleRuleActive(ctx: StateContext<GovernanceStateModel>, { id }: ToggleGovernanceRuleActive): rxjs.Observable<Response<GovernanceRule>> | undefined;
+    getModules(ctx: StateContext<GovernanceStateModel>): rxjs.Observable<Response<GovernanceModule[]>> | undefined;
+    clearSelectedRule(ctx: StateContext<GovernanceStateModel>): void;
+    getRequestSchemas(ctx: StateContext<GovernanceStateModel>, { targetScope, targetModuleKey }: GetRequestSchemas): rxjs.Observable<Response<GovernanceRequestSchema[]>> | undefined;
+    getProperties(ctx: StateContext<GovernanceStateModel>, { targetScope, targetModuleKey }: GetProperties): rxjs.Observable<Response<GovernanceProperty[]>> | undefined;
+    clearRequestSchemas(ctx: StateContext<GovernanceStateModel>): void;
+    clearProperties(ctx: StateContext<GovernanceStateModel>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GovernanceState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GovernanceState>;
+}
+
+declare class GovernanceRulesList implements OnDestroy {
+    levelId: _angular_core.InputSignal<number>;
+    typeCol: _angular_core.Signal<TemplateRef<any>>;
+    scopeCol: _angular_core.Signal<TemplateRef<any>>;
+    priorityCol: _angular_core.Signal<TemplateRef<any>>;
+    private readonly facade;
+    readonly modal: ModalService;
+    private readonly translocoService;
+    breadcrumbItems: _angular_core.WritableSignal<({
+        label: string;
+        icon: string;
+        routerLink: string;
+    } | {
+        label: string;
+        routerLink: string;
+        icon?: undefined;
+    } | {
+        label: string;
+        icon?: undefined;
+        routerLink?: undefined;
+    })[]>;
+    rules: _angular_core.Signal<GovernanceRule[]>;
+    tabs: _angular_core.WritableSignal<{
+        label: string;
+        value: string;
+    }[]>;
+    activeTab: _angular_core.WritableSignal<string>;
+    tableActions: _angular_core.WritableSignal<TableAction[]>;
+    deletingRowIds: _angular_core.WritableSignal<any[]>;
+    rowActions: _angular_core.WritableSignal<TableAction[]>;
+    tableColumns: _angular_core.WritableSignal<ColumnDef[]>;
+    loading: _angular_core.Signal<boolean>;
+    private allRules;
+    private activeRules;
+    private inactiveRules;
+    ngOnDestroy(): void;
+    openRuleDialog(rule?: GovernanceRule | null): void;
+    onCellChange(event: CellChangeEvent): void;
+    private getRuleTypeOptions;
+    getRuleTypeChipClass(ruleTypeKey: string): string;
+    getScopeIcon(scope: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GovernanceRulesList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GovernanceRulesList, "mt-governance-rules-list", never, { "levelId": { "alias": "levelId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GovernanceRuleForm implements OnInit {
+    modal: ModalService;
+    ref: ModalRef;
+    private readonly translocoService;
+    private readonly facade;
+    ruleForEdit: _angular_core.InputSignal<GovernanceRule | null>;
+    selectedRule: _angular_core.Signal<GovernanceRule | null>;
+    ruleTypes: _angular_core.Signal<GovernanceRuleType[]>;
+    isLoadingRule: _angular_core.Signal<boolean>;
+    isAddingRule: _angular_core.Signal<boolean>;
+    isUpdatingRule: _angular_core.Signal<boolean>;
+    modules: _angular_core.Signal<_masterteam_governance.GovernanceModule[]>;
+    requestSchemas: _angular_core.Signal<_masterteam_governance.GovernanceRequestSchema[]>;
+    properties: _angular_core.Signal<_masterteam_governance.GovernanceProperty[]>;
+    isLoadingRequestSchemas: _angular_core.Signal<boolean>;
+    isLoadingProperties: _angular_core.Signal<boolean>;
+    ruleFormControl: FormControl<any>;
+    formValue: _angular_core.Signal<any>;
+    selectedRuleType: _angular_core.Signal<GovernanceRuleType | null>;
+    targetScope: _angular_core.Signal<any>;
+    targetModuleKey: _angular_core.Signal<any>;
+    requestSchemaOptions: _angular_core.Signal<ConfigurationFieldOption[]>;
+    propertyOptions: _angular_core.Signal<ConfigurationFieldOption[]>;
+    moduleOptions: _angular_core.Signal<ConfigurationFieldOption[]>;
+    scopeOptions: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    operationOptions: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    ruleTypeOptions: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    formConfig: _angular_core.Signal<DynamicFormConfig>;
+    constructor();
+    /**
+     * Extract default values from rule type's configuration schema
+     */
+    private getDefaultsFromSchema;
+    ngOnInit(): void;
+    onSubmit(): void;
+    private buildConfigurationSection;
+    private buildConfigFieldsForType;
+    /**
+     * Convert a ConfigurationFieldSchema to DynamicForm BaseFieldConfig
+     */
+    private schemaFieldToFormField;
+    /**
+     * Get options for a field based on its optionsSource
+     * - 'static' or 'auto-populated': Use options from schema (already in API response)
+     * - 'requestSchema': Use fetched request schemas from state
+     * - 'properties': Use fetched properties from state
+     */
+    private getOptionsForField;
+    private unpackRuleToForm;
+    private packFormToCreateDto;
+    private packFormToUpdateDto;
+    private extractConfiguration;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GovernanceRuleForm, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GovernanceRuleForm, "mt-governance-rule-form", never, { "ruleForEdit": { "alias": "ruleForEdit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AddGovernanceRule, ClearProperties, ClearRequestSchemas, ClearSelectedRule, DeleteGovernanceRule, GetGovernanceRule, GetGovernanceRuleTypes, GetGovernanceRules, GetModules, GetProperties, GetRequestSchemas, GovernanceActionKey, GovernanceFacade, GovernanceRuleForm, GovernanceRuleTypeEnum, GovernanceRulesList, GovernanceState, ResetGovernanceState, SetLevelId, ToggleGovernanceRuleActive, UpdateGovernanceRule };
+export type { ConfigurationFieldOption, ConfigurationFieldSchema, CreateGovernanceRuleDto, GovernanceModule, GovernanceProperty, GovernanceRequestSchema, GovernanceRule, GovernanceRuleType, GovernanceStateModel, GovernanceViolation, GovernanceViolationError, OptionsSource, Translatable, UpdateGovernanceRuleDto };