@acorex-platform/module-software-management-client 0.0.46

package/types/acorex-platform-module-software-management-client-contracts.d.ts

@@ -0,0 +1,547 @@
+import { AXPModuleManifest, AXPWorkflowDefinition } from '@acorex-platform/framework-shared/core';
+import { AXPEntityModel, AXPRecordWorkflowInfo } from '@acorex-platform/framework-shared/entity';
+
+/**
+ * Applications & Platform capability for defining standalone software products.
+ * Group ids live in `AXPCommonPermissionGroupKeys`.
+ */
+declare const AXPSoftwareManagementPermissionKeys: {
+    readonly MaintainSoftwareDefinitions: "ApplicationsPlatform:Permission:MaintainSoftwareDefinitions";
+};
+
+declare const AXPSoftwareManagementMenuKeys: {
+    readonly Root: "SoftwareManagement:Menu";
+    readonly Software: "SoftwareManagement:Menu:Software";
+    readonly DiscoveryItems: "SoftwareManagement:Menu:DiscoveryItems";
+    readonly ScopeItems: "SoftwareManagement:Menu:ScopeItems";
+    readonly Requirements: "SoftwareManagement:Menu:Requirements";
+    readonly AcceptanceCriteria: "SoftwareManagement:Menu:AcceptanceCriteria";
+    readonly BusinessRules: "SoftwareManagement:Menu:BusinessRules";
+    readonly Modules: "SoftwareManagement:Menu:Modules";
+    readonly Features: "SoftwareManagement:Menu:Features";
+    readonly UseCases: "SoftwareManagement:Menu:UseCases";
+    readonly DesignDecisions: "SoftwareManagement:Menu:DesignDecisions";
+};
+
+declare const RootConfig: {
+    readonly config: {
+        readonly i18n: "software-management";
+        readonly module: "SoftwareManagement";
+    };
+    readonly module: {
+        readonly module: "software-management";
+        readonly name: "SoftwareManagement";
+        readonly title: "@software-management:module.title";
+        readonly icon: "fa-light fa-diagram-project";
+    };
+    readonly entities: {
+        readonly software: {
+            readonly name: "Software";
+            readonly source: "SoftwareManagement.Software";
+            readonly title: "@software-management:entities.software.title";
+            readonly titlePlural: "@software-management:entities.software.plural";
+            readonly icon: "fa-light fa-lightbulb";
+        };
+        readonly discoveryItem: {
+            readonly name: "SoftwareDiscoveryItem";
+            readonly source: "SoftwareManagement.SoftwareDiscoveryItem";
+            readonly title: "@software-management:entities.discovery-item.title";
+            readonly titlePlural: "@software-management:entities.discovery-item.plural";
+            readonly icon: "fa-light fa-magnifying-glass";
+        };
+        readonly scopeItem: {
+            readonly name: "SoftwareScopeItem";
+            readonly source: "SoftwareManagement.SoftwareScopeItem";
+            readonly title: "@software-management:entities.scope-item.title";
+            readonly titlePlural: "@software-management:entities.scope-item.plural";
+            readonly icon: "fa-light fa-border-outer";
+        };
+        readonly requirement: {
+            readonly name: "SoftwareRequirement";
+            readonly source: "SoftwareManagement.SoftwareRequirement";
+            readonly title: "@software-management:entities.requirement.title";
+            readonly titlePlural: "@software-management:entities.requirement.plural";
+            readonly icon: "fa-light fa-list-check";
+        };
+        readonly acceptanceCriterion: {
+            readonly name: "SoftwareAcceptanceCriterion";
+            readonly source: "SoftwareManagement.SoftwareAcceptanceCriterion";
+            readonly title: "@software-management:entities.acceptance-criterion.title";
+            readonly titlePlural: "@software-management:entities.acceptance-criterion.plural";
+            readonly icon: "fa-light fa-badge-check";
+        };
+        readonly businessRule: {
+            readonly name: "SoftwareBusinessRule";
+            readonly source: "SoftwareManagement.SoftwareBusinessRule";
+            readonly title: "@software-management:entities.business-rule.title";
+            readonly titlePlural: "@software-management:entities.business-rule.plural";
+            readonly icon: "fa-light fa-scale-balanced";
+        };
+        readonly module: {
+            readonly name: "SoftwareModule";
+            readonly source: "SoftwareManagement.SoftwareModule";
+            readonly title: "@software-management:entities.module.title";
+            readonly titlePlural: "@software-management:entities.module.plural";
+            readonly icon: "fa-light fa-cubes";
+        };
+        readonly feature: {
+            readonly name: "SoftwareFeature";
+            readonly source: "SoftwareManagement.SoftwareFeature";
+            readonly title: "@software-management:entities.feature.title";
+            readonly titlePlural: "@software-management:entities.feature.plural";
+            readonly icon: "fa-light fa-puzzle-piece";
+        };
+        readonly useCase: {
+            readonly name: "SoftwareUseCase";
+            readonly source: "SoftwareManagement.SoftwareUseCase";
+            readonly title: "@software-management:entities.use-case.title";
+            readonly titlePlural: "@software-management:entities.use-case.plural";
+            readonly icon: "fa-light fa-person-walking-arrow-right";
+        };
+        readonly designDecision: {
+            readonly name: "SoftwareDesignDecision";
+            readonly source: "SoftwareManagement.SoftwareDesignDecision";
+            readonly title: "@software-management:entities.design-decision.title";
+            readonly titlePlural: "@software-management:entities.design-decision.plural";
+            readonly icon: "fa-light fa-compass-drafting";
+        };
+    };
+};
+
+declare const SoftwareManagementManifest: AXPModuleManifest;
+
+declare const AXPSoftwareManagementCommandKeys: {
+    readonly Software: {
+        readonly StartFlow: "SoftwareManagement.Software:StartFlow";
+        readonly CompletePhase: "SoftwareManagement.Software:CompletePhase";
+        readonly AcceptSuggestion: "SoftwareManagement:AcceptSuggestion";
+        readonly GenerateKickoffSheet: "SoftwareManagement.Software:GenerateKickoffSheet";
+        readonly SubmitKickoffSheet: "SoftwareManagement.Software:SubmitKickoffSheet";
+        readonly ExportKickoffPdf: "SoftwareManagement.Software:ExportKickoffPdf";
+        readonly OpenKickoffSheet: "SoftwareManagement.Software:OpenKickoffSheet";
+        readonly ViewPinnedKickoff: "SoftwareManagement.Software:ViewPinnedKickoff";
+        readonly GenerateDiscoveryReport: "SoftwareManagement.Software:GenerateDiscoveryReport";
+        readonly SubmitDiscoveryReport: "SoftwareManagement.Software:SubmitDiscoveryReport";
+        readonly ExportDiscoveryReportPdf: "SoftwareManagement.Software:ExportDiscoveryReportPdf";
+        readonly OpenDiscoveryReport: "SoftwareManagement.Software:OpenDiscoveryReport";
+        readonly LinkDiscoveryQuestionnaire: "SoftwareManagement.Software:LinkDiscoveryQuestionnaire";
+    };
+    readonly WorkflowActivity: {
+        readonly CompletePhase: "workflow-activity:complete-software-phase";
+        readonly LoadIntroduction: "workflow-activity:load-software-introduction";
+        readonly SaveIntroduction: "workflow-activity:save-software-introduction";
+    };
+};
+
+declare const SOFTWARE_PHASES: readonly ["introduction", "discovery", "first-version-scope", "behavior-specification", "design", "delivery-planning"];
+type SoftwarePhase = (typeof SOFTWARE_PHASES)[number];
+declare const SOFTWARE_DEFINITION_WORKFLOW_NAME = "software-definition";
+declare function softwarePhaseIndex(phase: string | null | undefined): number;
+declare function nextSoftwarePhase(phase: string | null | undefined): SoftwarePhase | null;
+declare function isSoftwarePhaseAtLeast(current: string | null | undefined, required: SoftwarePhase): boolean;
+
+declare const SOFTWARE_ORIGINS: readonly ["original", "assumption", "suggestion", "approved-fact"];
+type SoftwareOrigin = (typeof SOFTWARE_ORIGINS)[number];
+declare const SOFTWARE_PROPOSED_BY: readonly ["user", "ai"];
+type SoftwareProposedBy = (typeof SOFTWARE_PROPOSED_BY)[number];
+declare const SOFTWARE_DISCOVERY_KINDS: readonly ["audience", "problem", "pain", "current-practice", "constraint", "alternative", "hypothesis", "evidence", "unknown"];
+type SoftwareDiscoveryKind = (typeof SOFTWARE_DISCOVERY_KINDS)[number];
+declare const SOFTWARE_SCOPE_KINDS: readonly ["capability", "out-of-scope", "success-metric"];
+type SoftwareScopeKind = (typeof SOFTWARE_SCOPE_KINDS)[number];
+declare const SOFTWARE_DESIGN_KINDS: readonly ["data-model", "ux", "technical"];
+type SoftwareDesignKind = (typeof SOFTWARE_DESIGN_KINDS)[number];
+
+declare const softwareDefinitionWorkflowDefinition: AXPWorkflowDefinition;
+
+/** Document type name in Document Management. One kickoff sheet per Software record. */
+declare const DISCOVERY_KICKOFF_DOCUMENT_TYPE_NAME = "software-discovery-kickoff";
+declare const DISCOVERY_KICKOFF_FILE_NAME = "discovery-kickoff.html";
+/**
+ * Review statuses stored on DocumentManagement.Document.
+ * Same vocabulary as the EDMS document review workflow.
+ */
+declare const KICKOFF_REVIEW_STATUS: {
+    readonly Draft: "draft";
+    readonly InReview: "in-review";
+    readonly Approved: "approved";
+    readonly Rejected: "rejected";
+    readonly RevisionRequested: "revision-requested";
+};
+type KickoffReviewStatus = (typeof KICKOFF_REVIEW_STATUS)[keyof typeof KICKOFF_REVIEW_STATUS];
+declare const KICKOFF_REVIEW_REASON_BASE_DATA = "introduction-fields-changed";
+/** Fields whose change must not silently rewrite an approved sheet. */
+declare const KICKOFF_SOURCE_FIELDS: readonly ["title", "idea", "originalIdea", "initialProblem", "goal", "ownerId", "potentialUsers", "openQuestions"];
+type KickoffCertainty = 'recorded' | 'hypothesis' | 'unknown';
+interface DiscoveryKickoffSource {
+    title?: unknown;
+    idea?: unknown;
+    originalIdea?: unknown;
+    initialProblem?: unknown;
+    goal?: unknown;
+    ownerId?: unknown;
+    ownerName?: unknown;
+    potentialUsers?: unknown;
+    openQuestions?: unknown;
+    proposedBy?: unknown;
+    origin?: unknown;
+}
+interface DiscoveryKickoffSection {
+    key: string;
+    titleEn: string;
+    titleFa: string;
+    body: string;
+    certainty: KickoffCertainty;
+}
+interface DiscoveryKickoffSheet {
+    title: string;
+    fingerprint: string;
+    html: string;
+    plainText: string;
+    sections: DiscoveryKickoffSection[];
+    aiDraft: boolean;
+}
+interface DiscoveryKickoffMeta {
+    bodyHtml?: string;
+    plainText?: string;
+    fingerprint?: string;
+    aiDraft?: boolean;
+    sections?: DiscoveryKickoffSection[];
+}
+/** What introduction must see before it may advance. Discovery reads `approvedVersionId`. */
+interface IntroductionKickoffCheck {
+    statusId?: string | null;
+    hostVersionId?: string | null;
+    approvedVersionId?: string | null;
+    approvedFingerprint?: string | null;
+}
+declare const INTRODUCTION_REQUIRED_FIELDS: readonly ["title", "idea", "initialProblem", "goal", "ownerId"];
+type IntroductionRequiredField = (typeof INTRODUCTION_REQUIRED_FIELDS)[number];
+declare const INTRODUCTION_EXIT_MESSAGE: {
+    readonly missingFields: "@software-management:messages.introduction.missing-fields";
+    readonly kickoffRejected: "@software-management:messages.introduction.kickoff-rejected";
+    readonly kickoffRevision: "@software-management:messages.introduction.kickoff-revision";
+    readonly kickoffInReview: "@software-management:messages.introduction.kickoff-in-review";
+    readonly kickoffDraft: "@software-management:messages.introduction.kickoff-draft";
+    readonly kickoffMissing: "@software-management:messages.introduction.kickoff-missing";
+    readonly kickoffRequired: "@software-management:messages.introduction.kickoff-required";
+    readonly kickoffPinMissing: "@software-management:messages.introduction.kickoff-pin-missing";
+    readonly kickoffFingerprintMissing: "@software-management:messages.introduction.kickoff-fingerprint-missing";
+    readonly kickoffStale: "@software-management:messages.introduction.kickoff-stale";
+    readonly kickoffNotApproved: "@software-management:messages.introduction.kickoff-not-approved";
+    readonly kickoffVersionMismatch: "@software-management:messages.introduction.kickoff-version-mismatch";
+    readonly ready: "@software-management:messages.introduction.ready";
+    readonly saved: "@software-management:messages.introduction.saved";
+};
+interface IntroductionExitDecision {
+    ok: boolean;
+    message: string;
+    /** Document version discovery must keep using. Empty until a version is approved. */
+    discoveryVersionId: string;
+    /** Required introduction fields that are still empty after lookup and locale coercion. */
+    missingFields?: IntroductionRequiredField[];
+}
+declare function kickoffText(value: unknown): string;
+/** Review status stored as a string or as a lookup `{ id }`. */
+declare function kickoffStatusId(value: unknown): string;
+/**
+ * Reads introduction text from a string, a locale map, or a lookup stub such as `{ id, displayName }`.
+ * A lookup stub contributes its id. Other objects contribute the first non-empty locale string.
+ */
+declare function introductionValueText(value: unknown): string;
+declare function missingIntroductionFields(software: DiscoveryKickoffSource): IntroductionRequiredField[];
+/** Stable id of the introduction inputs baked into a sheet version. */
+declare function discoveryKickoffFingerprint(source: DiscoveryKickoffSource): string;
+declare function kickoffSourceFromSoftware(software: DiscoveryKickoffSource & {
+    owner?: {
+        displayName?: unknown;
+    };
+}): DiscoveryKickoffSource;
+/**
+ * Builds the discovery kickoff sheet from introduction fields only.
+ * Empty research items stay Unknown. Author-supplied guesses stay Hypothesis.
+ * AI text is a draft: it is never labeled as evidence or a confirmed fact.
+ */
+declare function buildDiscoveryKickoffSheet(source: DiscoveryKickoffSource): DiscoveryKickoffSheet;
+declare function readKickoffMeta(value: unknown): DiscoveryKickoffMeta;
+/** Fingerprint stored on the version, with the host document as fallback. */
+declare function kickoffFingerprintFromRows(version: {
+    metaDataForm?: unknown;
+} | null | undefined, host?: {
+    metaDataForm?: unknown;
+} | null): string;
+declare function kickoffReviewKeepsIntroduction(statusId: string | null | undefined): boolean;
+/**
+ * Fills the gate check from the document when an approved host version exists
+ * but the software row has not stored that version yet.
+ * An unapproved sheet never becomes the pinned version here.
+ */
+declare function buildIntroductionKickoffCheck(input: {
+    statusId?: unknown;
+    status?: unknown;
+    hostVersionId?: unknown;
+    approvedVersionId?: unknown;
+    approvedFingerprint?: unknown;
+    versionFingerprint?: unknown;
+} | null | undefined): IntroductionKickoffCheck | null;
+/**
+ * Introduction may leave only when one specific document version is approved
+ * and still matches the current introduction fields.
+ * Discovery must keep using `discoveryVersionId`, not a later draft.
+ */
+declare function evaluateIntroductionExit(software: DiscoveryKickoffSource, kickoff: IntroductionKickoffCheck | null | undefined): IntroductionExitDecision;
+/**
+ * PDF bytes must be rendered from the approved version's stored HTML.
+ * Rebuilding from later introduction fields is not allowed.
+ */
+declare function approvedKickoffPdfSource(version: {
+    id?: unknown;
+    metaDataForm?: unknown;
+} | null | undefined, approvedVersionId: string): {
+    ok: boolean;
+    html: string;
+    message: string;
+};
+/**
+ * A later edit must keep the approved HTML intact and ask for a new version.
+ */
+declare function kickoffAfterBaseDataChange(approved: {
+    html: string;
+    fingerprint: string;
+}, next: DiscoveryKickoffSource): {
+    approvedHtml: string;
+    needsReview: boolean;
+    reviewReason: string;
+    nextFingerprint: string;
+};
+
+declare const DISCOVERY_REPORT_DOCUMENT_TYPE_NAME = "software-discovery-report";
+declare const DISCOVERY_REPORT_FILE_NAME = "discovery-report.html";
+declare const DISCOVERY_DECISIONS: readonly ["proceed", "revise", "stop"];
+type DiscoveryDecision = (typeof DISCOVERY_DECISIONS)[number];
+declare const DISCOVERY_STANCES: readonly ["assumption", "validated"];
+type DiscoveryStance = (typeof DISCOVERY_STANCES)[number];
+declare const DISCOVERY_METHODS: readonly ["interview", "observation", "analytics", "document", "questionnaire", "other"];
+type DiscoveryMethod = (typeof DISCOVERY_METHODS)[number];
+declare const DISCOVERY_FINDINGS_CHANGED = "discovery-findings-changed";
+interface DiscoveryFindingRecord {
+    id?: unknown;
+    kind?: unknown;
+    title?: unknown;
+    body?: unknown;
+    stance?: unknown;
+    method?: unknown;
+    researchDate?: unknown;
+    userGroup?: unknown;
+    claim?: unknown;
+    sourceRefs?: unknown;
+    kickoffVersionId?: unknown;
+}
+interface DiscoveryReportSource {
+    kickoffVersionId: string;
+    kickoffPlainText: string;
+    decision: string;
+    rationale: string;
+    findings: DiscoveryFindingRecord[];
+}
+interface DiscoveryReportSheet {
+    fingerprint: string;
+    html: string;
+    plainText: string;
+}
+interface DiscoveryExitDecision {
+    ok: boolean;
+    advance: boolean;
+    message: string;
+    discoveryVersionId: string;
+}
+declare function discoveryStance(value: unknown): DiscoveryStance;
+declare function parseSourceRefs(value: unknown): string[];
+declare function findingSupportsProceed(finding: DiscoveryFindingRecord): boolean;
+declare function discoveryReportFingerprint(source: DiscoveryReportSource): string;
+declare function kickoffPlainTextFromVersion(version: {
+    metaDataForm?: unknown;
+} | null | undefined): string;
+declare function buildDiscoveryReport(source: DiscoveryReportSource): DiscoveryReportSheet;
+declare function evaluateDiscoveryExit(input: {
+    currentPhase?: unknown;
+    decision?: unknown;
+    rationale?: unknown;
+    kickoffApprovedVersionId?: unknown;
+    findings?: DiscoveryFindingRecord[];
+    statusId?: unknown;
+    hostVersionId?: unknown;
+    approvedVersionId?: unknown;
+    approvedFingerprint?: unknown;
+    reportFingerprint?: unknown;
+}): DiscoveryExitDecision;
+
+declare function textPresent(value: unknown): boolean;
+declare function canCompleteIntroduction(software: {
+    title?: unknown;
+    idea?: unknown;
+    initialProblem?: unknown;
+    goal?: unknown;
+    ownerId?: unknown;
+}): boolean;
+declare function isIntroductionComplete(software: {
+    introductionCompletedAt?: unknown;
+    currentPhase?: unknown;
+}): boolean;
+declare function canLinkProject(software: {
+    introductionCompletedAt?: unknown;
+    currentPhase?: unknown;
+}): boolean;
+declare function canWriteDesignKind(software: {
+    currentPhase?: unknown;
+}, kind: string | undefined): boolean;
+declare const INTRODUCTION_UPSTREAM_FIELDS: readonly ["title", "idea", "initialProblem", "goal", "ownerId", "potentialUsers", "openQuestions"];
+declare function canCompletePhase(phase: SoftwarePhase, software: {
+    title?: unknown;
+    idea?: unknown;
+    originalIdea?: unknown;
+    initialProblem?: unknown;
+    goal?: unknown;
+    ownerId?: unknown;
+    potentialUsers?: unknown;
+    openQuestions?: unknown;
+    proposedBy?: unknown;
+    origin?: unknown;
+    currentPhase?: unknown;
+    introductionCompletedAt?: unknown;
+}, kickoff?: IntroductionKickoffCheck | null, discovery?: Parameters<typeof evaluateDiscoveryExit>[0] | null): {
+    ok: boolean;
+    message: string;
+    advance?: boolean;
+    missingFields?: IntroductionRequiredField[];
+};
+
+interface AXMSoftwareManagementProvenanceFields {
+    origin?: SoftwareOrigin;
+    proposedBy?: SoftwareProposedBy;
+    acceptedAt?: Date | string | null;
+    needsReview?: boolean;
+    reviewReason?: string;
+    sourceNote?: string;
+}
+interface AXMSoftwareManagementSoftwareEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    title: string;
+    idea: string;
+    originalIdea?: string;
+    initialProblem?: string;
+    goal?: string;
+    ownerId?: string;
+    owner?: {
+        id: string;
+        displayName?: string;
+    };
+    /** Author guess only. The kickoff sheet labels this Hypothesis, or Unknown when empty. */
+    potentialUsers?: string;
+    /** Open questions only. The kickoff sheet labels these Hypothesis, or Unknown when empty. */
+    openQuestions?: string;
+    code?: string;
+    currentPhase?: SoftwarePhase;
+    kickoffDocumentId?: string;
+    /** DocumentManagement.DocumentVersion id discovery must read. */
+    kickoffApprovedVersionId?: string;
+    kickoffApprovedFingerprint?: string;
+    discoveryReportDocumentId?: string;
+    /** DocumentManagement.DocumentVersion id the next stage must read. */
+    discoveryApprovedVersionId?: string;
+    discoveryApprovedFingerprint?: string;
+    discoveryDecision?: 'proceed' | 'revise' | 'stop' | string;
+    discoveryRationale?: string;
+    introductionCompletedAt?: Date | string | null;
+    definitionCompletedAt?: Date | string | null;
+    projectId?: string;
+    project?: {
+        id: string;
+        title?: unknown;
+    };
+    workflowInfo?: AXPRecordWorkflowInfo;
+}
+
+interface AXMSoftwareManagementSoftwareDiscoveryItemEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    kind: SoftwareDiscoveryKind;
+    title: string;
+    body?: string;
+    /** assumption until research validates the claim. */
+    stance?: 'assumption' | 'validated';
+    method?: string;
+    researchDate?: string;
+    userGroup?: string;
+    claim?: string;
+    /** One source reference per line. A finding may cite several, including questionnaire sessions. */
+    sourceRefs?: string;
+    /** Approved introduction version this item investigates. */
+    kickoffVersionId?: string;
+}
+
+interface AXMSoftwareManagementSoftwareScopeItemEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    kind: SoftwareScopeKind;
+    title: string;
+    body?: string;
+    metricBaseline?: string;
+    metricTarget?: string;
+}
+
+interface AXMSoftwareManagementSoftwareRequirementEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    scopedId?: string;
+    title: string;
+    statement: string;
+    priority?: string;
+}
+
+interface AXMSoftwareManagementSoftwareAcceptanceCriterionEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    requirementId: string;
+    statement: string;
+}
+
+interface AXMSoftwareManagementSoftwareBusinessRuleEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    title: string;
+    statement: string;
+    trigger?: string;
+    consequence?: string;
+}
+
+interface AXMSoftwareManagementSoftwareModuleEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    code: string;
+    title: string;
+    responsibility?: string;
+}
+
+interface AXMSoftwareManagementSoftwareFeatureEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    moduleId: string;
+    code: string;
+    title: string;
+    summary?: string;
+}
+
+interface AXMSoftwareManagementSoftwareUseCaseEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    featureId?: string;
+    requirementId?: string;
+    code: string;
+    title: string;
+    primaryActor?: string;
+    preconditions?: string;
+    mainFlow?: string;
+    postconditions?: string;
+}
+
+interface AXMSoftwareManagementSoftwareDesignDecisionEntityModel extends AXPEntityModel<string>, AXMSoftwareManagementProvenanceFields {
+    softwareId: string;
+    kind: SoftwareDesignKind;
+    title: string;
+    body?: string;
+    technology?: string;
+}
+
+export { AXPSoftwareManagementCommandKeys, AXPSoftwareManagementMenuKeys, AXPSoftwareManagementPermissionKeys, DISCOVERY_DECISIONS, DISCOVERY_FINDINGS_CHANGED, DISCOVERY_KICKOFF_DOCUMENT_TYPE_NAME, DISCOVERY_KICKOFF_FILE_NAME, DISCOVERY_METHODS, DISCOVERY_REPORT_DOCUMENT_TYPE_NAME, DISCOVERY_REPORT_FILE_NAME, DISCOVERY_STANCES, INTRODUCTION_EXIT_MESSAGE, INTRODUCTION_REQUIRED_FIELDS, INTRODUCTION_UPSTREAM_FIELDS, KICKOFF_REVIEW_REASON_BASE_DATA, KICKOFF_REVIEW_STATUS, KICKOFF_SOURCE_FIELDS, RootConfig, SOFTWARE_DEFINITION_WORKFLOW_NAME, SOFTWARE_DESIGN_KINDS, SOFTWARE_DISCOVERY_KINDS, SOFTWARE_ORIGINS, SOFTWARE_PHASES, SOFTWARE_PROPOSED_BY, SOFTWARE_SCOPE_KINDS, SoftwareManagementManifest, approvedKickoffPdfSource, buildDiscoveryKickoffSheet, buildDiscoveryReport, buildIntroductionKickoffCheck, canCompleteIntroduction, canCompletePhase, canLinkProject, canWriteDesignKind, discoveryKickoffFingerprint, discoveryReportFingerprint, discoveryStance, evaluateDiscoveryExit, evaluateIntroductionExit, findingSupportsProceed, introductionValueText, isIntroductionComplete, isSoftwarePhaseAtLeast, kickoffAfterBaseDataChange, kickoffFingerprintFromRows, kickoffPlainTextFromVersion, kickoffReviewKeepsIntroduction, kickoffSourceFromSoftware, kickoffStatusId, kickoffText, missingIntroductionFields, nextSoftwarePhase, parseSourceRefs, readKickoffMeta, softwareDefinitionWorkflowDefinition, softwarePhaseIndex, textPresent };
+export type { AXMSoftwareManagementProvenanceFields, AXMSoftwareManagementSoftwareAcceptanceCriterionEntityModel, AXMSoftwareManagementSoftwareBusinessRuleEntityModel, AXMSoftwareManagementSoftwareDesignDecisionEntityModel, AXMSoftwareManagementSoftwareDiscoveryItemEntityModel, AXMSoftwareManagementSoftwareEntityModel, AXMSoftwareManagementSoftwareFeatureEntityModel, AXMSoftwareManagementSoftwareModuleEntityModel, AXMSoftwareManagementSoftwareRequirementEntityModel, AXMSoftwareManagementSoftwareScopeItemEntityModel, AXMSoftwareManagementSoftwareUseCaseEntityModel, DiscoveryDecision, DiscoveryExitDecision, DiscoveryFindingRecord, DiscoveryKickoffMeta, DiscoveryKickoffSection, DiscoveryKickoffSheet, DiscoveryKickoffSource, DiscoveryMethod, DiscoveryReportSheet, DiscoveryReportSource, DiscoveryStance, IntroductionExitDecision, IntroductionKickoffCheck, IntroductionRequiredField, KickoffCertainty, KickoffReviewStatus, SoftwareDesignKind, SoftwareDiscoveryKind, SoftwareOrigin, SoftwarePhase, SoftwareProposedBy, SoftwareScopeKind };

package/types/acorex-platform-module-software-management-client.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from '@angular/core';
+
+declare class AXMSoftwareManagementModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMSoftwareManagementModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMSoftwareManagementModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXMSoftwareManagementModule>;
+}
+
+export { AXMSoftwareManagementModule };