@llm-dev-ops/agentics-cli 1.4.87 → 1.4.90

package/dist/server/schemas.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+export declare const ManageDomainEnterpriseSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageDomainEnterpriseInput = z.infer<typeof ManageDomainEnterpriseSchema>;
+export declare const QueryDomainEnterpriseSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryDomainEnterpriseInput = z.infer<typeof QueryDomainEnterpriseSchema>;
+export declare const GetDomainEnterpriseSolutionSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetDomainEnterpriseSolutionParams = z.infer<typeof GetDomainEnterpriseSolutionSchema>;
+export declare const GetDomainEnterpriseSolutionByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetDomainEnterpriseSolutionByIdParams = z.infer<typeof GetDomainEnterpriseSolutionByIdSchema>;
+export declare const ManageMonitoringAlertsSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageMonitoringAlertsInput = z.infer<typeof ManageMonitoringAlertsSchema>;
+export declare const QueryMonitoringAlertsSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryMonitoringAlertsInput = z.infer<typeof QueryMonitoringAlertsSchema>;
+export declare const GetMonitoringAlertsSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetMonitoringAlertsParams = z.infer<typeof GetMonitoringAlertsSchema>;
+export declare const GetMonitoringAlertsByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetMonitoringAlertsByIdParams = z.infer<typeof GetMonitoringAlertsByIdSchema>;
+export declare const ManageOngoingRegularSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageOngoingRegularInput = z.infer<typeof ManageOngoingRegularSchema>;
+export declare const QueryOngoingRegularSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryOngoingRegularInput = z.infer<typeof QueryOngoingRegularSchema>;
+export declare const GetOngoingRegularStakeholderSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetOngoingRegularStakeholderParams = z.infer<typeof GetOngoingRegularStakeholderSchema>;
+export declare const GetOngoingRegularStakeholderByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetOngoingRegularStakeholderByIdParams = z.infer<typeof GetOngoingRegularStakeholderByIdSchema>;
+export declare const ManageRiskMitigationSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageRiskMitigationInput = z.infer<typeof ManageRiskMitigationSchema>;
+export declare const QueryRiskMitigationSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryRiskMitigationInput = z.infer<typeof QueryRiskMitigationSchema>;
+export declare const GetRiskMitigationPlanSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetRiskMitigationPlanParams = z.infer<typeof GetRiskMitigationPlanSchema>;
+export declare const GetRiskMitigationPlanByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetRiskMitigationPlanByIdParams = z.infer<typeof GetRiskMitigationPlanByIdSchema>;
+export declare const ManageTargetEnterpriseSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageTargetEnterpriseInput = z.infer<typeof ManageTargetEnterpriseSchema>;
+export declare const QueryTargetEnterpriseSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryTargetEnterpriseInput = z.infer<typeof QueryTargetEnterpriseSchema>;
+export declare const GetManageTargetEnterpriseSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetManageTargetEnterpriseParams = z.infer<typeof GetManageTargetEnterpriseSchema>;
+export declare const GetQueryTargetEnterpriseSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetQueryTargetEnterpriseParams = z.infer<typeof GetQueryTargetEnterpriseSchema>;
+export declare const GetTargetEnterpriseSystemSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetTargetEnterpriseSystemParams = z.infer<typeof GetTargetEnterpriseSystemSchema>;
+export declare const GetTargetEnterpriseSystemByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetTargetEnterpriseSystemByIdParams = z.infer<typeof GetTargetEnterpriseSystemByIdSchema>;
+export declare const ManageUnderwritingSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageUnderwritingInput = z.infer<typeof ManageUnderwritingSchema>;
+export declare const QueryUnderwritingSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryUnderwritingInput = z.infer<typeof QueryUnderwritingSchema>;
+export declare const ListUnderwritingSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type ListUnderwritingParams = z.infer<typeof ListUnderwritingSchema>;
+export declare const GetUnderwritingByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetUnderwritingByIdParams = z.infer<typeof GetUnderwritingByIdSchema>;
+export declare const ManageScopedPilotSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageScopedPilotInput = z.infer<typeof ManageScopedPilotSchema>;
+export declare const QueryScopedPilotSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryScopedPilotInput = z.infer<typeof QueryScopedPilotSchema>;
+export declare const GetScopedPilotReduceSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetScopedPilotReduceParams = z.infer<typeof GetScopedPilotReduceSchema>;
+export declare const GetScopedPilotReduceByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetScopedPilotReduceByIdParams = z.infer<typeof GetScopedPilotReduceByIdSchema>;
+export declare const ManageReEvaluateSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageReEvaluateInput = z.infer<typeof ManageReEvaluateSchema>;
+export declare const QueryReEvaluateSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryReEvaluateInput = z.infer<typeof QueryReEvaluateSchema>;
+export declare const GetReEvaluateRiskSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetReEvaluateRiskParams = z.infer<typeof GetReEvaluateRiskSchema>;
+export declare const GetReEvaluateRiskByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetReEvaluateRiskByIdParams = z.infer<typeof GetReEvaluateRiskByIdSchema>;
+export declare const ManageRecommendationSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type ManageRecommendationInput = z.infer<typeof ManageRecommendationSchema>;
+export declare const QueryRecommendationSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type QueryRecommendationInput = z.infer<typeof QueryRecommendationSchema>;
+export declare const ListRecommendationSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type ListRecommendationParams = z.infer<typeof ListRecommendationSchema>;
+export declare const GetRecommendationByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetRecommendationByIdParams = z.infer<typeof GetRecommendationByIdSchema>;
+export declare const RouteRequestsSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type RouteRequestsInput = z.infer<typeof RouteRequestsSchema>;
+export declare const AuthenticateSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type AuthenticateInput = z.infer<typeof AuthenticateSchema>;
+export declare const RateLimitSchema: z.ZodObject<{
+    request_payload: z.ZodString;
+}, z.core.$strip>;
+export type RateLimitInput = z.infer<typeof RateLimitSchema>;
+export declare const GetApiGatewaySchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetApiGatewayParams = z.infer<typeof GetApiGatewaySchema>;
+export declare const GetApiGatewayByIdSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type GetApiGatewayByIdParams = z.infer<typeof GetApiGatewayByIdSchema>;

package/dist/server/schemas.js

@@ -0,0 +1,185 @@
+// Generated by Phase 4 pipeline — do not edit manually
+import { z } from 'zod';
+// === DomainEnterpriseSolution Schemas ===
+export const ManageDomainEnterpriseSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryDomainEnterpriseSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetDomainEnterpriseSolutionSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetDomainEnterpriseSolutionByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === MonitoringAlerts Schemas ===
+export const ManageMonitoringAlertsSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryMonitoringAlertsSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetMonitoringAlertsSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetMonitoringAlertsByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === OngoingRegularStakeholder Schemas ===
+export const ManageOngoingRegularSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryOngoingRegularSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetOngoingRegularStakeholderSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetOngoingRegularStakeholderByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === RiskMitigationPlan Schemas ===
+export const ManageRiskMitigationSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryRiskMitigationSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetRiskMitigationPlanSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetRiskMitigationPlanByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === TargetEnterpriseSystem Schemas ===
+export const ManageTargetEnterpriseSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryTargetEnterpriseSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetManageTargetEnterpriseSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetQueryTargetEnterpriseSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetTargetEnterpriseSystemSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetTargetEnterpriseSystemByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === Underwriting Schemas ===
+export const ManageUnderwritingSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryUnderwritingSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const ListUnderwritingSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetUnderwritingByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === ScopedPilotReduce Schemas ===
+export const ManageScopedPilotSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryScopedPilotSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetScopedPilotReduceSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetScopedPilotReduceByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === ReEvaluateRisk Schemas ===
+export const ManageReEvaluateSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryReEvaluateSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetReEvaluateRiskSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetReEvaluateRiskByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === Recommendation Schemas ===
+export const ManageRecommendationSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const QueryRecommendationSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const ListRecommendationSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetRecommendationByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+// === ApiGateway Schemas ===
+export const RouteRequestsSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const AuthenticateSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const RateLimitSchema = z.object({
+    request_payload: z.string().min(1),
+});
+export const GetApiGatewaySchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});
+export const GetApiGatewayByIdSchema = z.object({
+    filters: z.string().optional(),
+    limit: z.coerce.number().int().positive().default(50),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});

package/dist/target-enterprise-system/infra/target-enterprise-system-adapter.d.ts

@@ -0,0 +1,25 @@
+import type { TargetEnterpriseSystemPort, TargetEnterpriseSystemInput, TargetEnterpriseSystem } from '../ports/target-enterprise-system.js';
+import type { Telemetry } from '../../infra/telemetry.js';
+import type { DbClient, ErpClient } from '../../infra/clients.js';
+/**
+ * Infrastructure adapter: TargetEnterpriseSystemAdapter
+ * Bounded context: target-enterprise-system
+ * ERP system: infor
+ *
+ * Bridges the TargetEnterpriseSystemPort port to the infor ERP system
+ * and the underlying database client.
+ */
+export declare class TargetEnterpriseSystemAdapter implements TargetEnterpriseSystemPort {
+    private readonly db;
+    private readonly erp;
+    private readonly telemetry;
+    constructor(db: DbClient, erp: ErpClient, telemetry: Telemetry);
+    /** Creates or updates target-enterprise-system record */
+    manageTargetEnterprise(input: TargetEnterpriseSystemInput): Promise<TargetEnterpriseSystem>;
+    /** Creates or updates target-enterprise-system record */
+    queryTargetEnterprise(input: TargetEnterpriseSystemInput): Promise<TargetEnterpriseSystem>;
+    /** Returns target-enterprise-system data */
+    listTargetEnterpriseSystem(input: Record<string, unknown>): Promise<TargetEnterpriseSystem[]>;
+    /** Returns target-enterprise-system data */
+    id(input: Record<string, unknown>): Promise<TargetEnterpriseSystem[]>;
+}

package/dist/target-enterprise-system/infra/target-enterprise-system-adapter.js

@@ -0,0 +1,47 @@
+// Generated by Phase 4 pipeline — do not edit manually
+/**
+ * Infrastructure adapter: TargetEnterpriseSystemAdapter
+ * Bounded context: target-enterprise-system
+ * ERP system: infor
+ *
+ * Bridges the TargetEnterpriseSystemPort port to the infor ERP system
+ * and the underlying database client.
+ */
+export class TargetEnterpriseSystemAdapter {
+    db;
+    erp;
+    telemetry;
+    constructor(db, erp, telemetry) {
+        this.db = db;
+        this.erp = erp;
+        this.telemetry = telemetry;
+    }
+    /** Creates or updates target-enterprise-system record */
+    async manageTargetEnterprise(input) {
+        return this.telemetry.withSpan('target_enterprise_system', 'manageTargetEnterprise', {}, async () => {
+            const result = await this.erp.invoke('manageTargetEnterprise', input);
+            return result;
+        });
+    }
+    /** Creates or updates target-enterprise-system record */
+    async queryTargetEnterprise(input) {
+        return this.telemetry.withSpan('target_enterprise_system', 'queryTargetEnterprise', {}, async () => {
+            const rows = await this.db.query('SELECT * FROM target_enterprise_system WHERE 1=1', []);
+            return rows;
+        });
+    }
+    /** Returns target-enterprise-system data */
+    async listTargetEnterpriseSystem(input) {
+        return this.telemetry.withSpan('target_enterprise_system', 'listTargetEnterpriseSystem', {}, async () => {
+            const rows = await this.db.query('SELECT * FROM target_enterprise_system WHERE 1=1', []);
+            return rows;
+        });
+    }
+    /** Returns target-enterprise-system data */
+    async id(input) {
+        return this.telemetry.withSpan('target_enterprise_system', 'id', {}, async () => {
+            const result = await this.erp.invoke('id', input);
+            return result;
+        });
+    }
+}

package/dist/target-enterprise-system/ports/target-enterprise-system.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Port interface for bounded context: target-enterprise-system
+ */
+export interface TargetEnterpriseSystemInput {
+    readonly id: string;
+    readonly target_enterprise_system_id: string;
+}
+export interface TargetEnterpriseSystem {
+    readonly id: string;
+    readonly created_at: string;
+    readonly updated_at: string;
+    readonly status: 'active' | 'inactive' | 'pending' | 'completed' | 'error';
+    readonly target_enterprise_system_id: string;
+}
+export interface TargetEnterpriseSystemPort {
+    /** Creates or updates target-enterprise-system record */
+    manageTargetEnterprise(input: TargetEnterpriseSystemInput): Promise<TargetEnterpriseSystem>;
+    /** Creates or updates target-enterprise-system record */
+    queryTargetEnterprise(input: TargetEnterpriseSystemInput): Promise<TargetEnterpriseSystem>;
+    /** Returns target-enterprise-system data */
+    listTargetEnterpriseSystem(input: Record<string, unknown>): Promise<TargetEnterpriseSystem[]>;
+    /** Returns target-enterprise-system data */
+    id(input: Record<string, unknown>): Promise<TargetEnterpriseSystem[]>;
+}

package/dist/target-enterprise-system/ports/target-enterprise-system.js

@@ -0,0 +1,2 @@
+// Generated by Phase 4 pipeline — do not edit manually
+export {};

package/dist/underwriting/infra/underwriting-adapter.d.ts

@@ -0,0 +1,25 @@
+import type { UnderwritingPort, UnderwritingInput, Underwriting } from '../ports/underwriting.js';
+import type { Telemetry } from '../../infra/telemetry.js';
+import type { DbClient, ErpClient } from '../../infra/clients.js';
+/**
+ * Infrastructure adapter: UnderwritingAdapter
+ * Bounded context: underwriting
+ * ERP system: infor
+ *
+ * Bridges the UnderwritingPort port to the infor ERP system
+ * and the underlying database client.
+ */
+export declare class UnderwritingAdapter implements UnderwritingPort {
+    private readonly db;
+    private readonly erp;
+    private readonly telemetry;
+    constructor(db: DbClient, erp: ErpClient, telemetry: Telemetry);
+    /** Creates or updates underwriting record */
+    manageUnderwriting(input: UnderwritingInput): Promise<Underwriting>;
+    /** Creates or updates underwriting record */
+    queryUnderwriting(input: UnderwritingInput): Promise<Underwriting>;
+    /** Returns underwriting data */
+    listUnderwriting(input: Record<string, unknown>): Promise<Underwriting[]>;
+    /** Returns underwriting data */
+    id(input: Record<string, unknown>): Promise<Underwriting[]>;
+}

package/dist/underwriting/infra/underwriting-adapter.js

@@ -0,0 +1,47 @@
+// Generated by Phase 4 pipeline — do not edit manually
+/**
+ * Infrastructure adapter: UnderwritingAdapter
+ * Bounded context: underwriting
+ * ERP system: infor
+ *
+ * Bridges the UnderwritingPort port to the infor ERP system
+ * and the underlying database client.
+ */
+export class UnderwritingAdapter {
+    db;
+    erp;
+    telemetry;
+    constructor(db, erp, telemetry) {
+        this.db = db;
+        this.erp = erp;
+        this.telemetry = telemetry;
+    }
+    /** Creates or updates underwriting record */
+    async manageUnderwriting(input) {
+        return this.telemetry.withSpan('underwriting', 'manageUnderwriting', {}, async () => {
+            const result = await this.erp.invoke('manageUnderwriting', input);
+            return result;
+        });
+    }
+    /** Creates or updates underwriting record */
+    async queryUnderwriting(input) {
+        return this.telemetry.withSpan('underwriting', 'queryUnderwriting', {}, async () => {
+            const rows = await this.db.query('SELECT * FROM underwriting WHERE 1=1', []);
+            return rows;
+        });
+    }
+    /** Returns underwriting data */
+    async listUnderwriting(input) {
+        return this.telemetry.withSpan('underwriting', 'listUnderwriting', {}, async () => {
+            const rows = await this.db.query('SELECT * FROM underwriting WHERE 1=1', []);
+            return rows;
+        });
+    }
+    /** Returns underwriting data */
+    async id(input) {
+        return this.telemetry.withSpan('underwriting', 'id', {}, async () => {
+            const result = await this.erp.invoke('id', input);
+            return result;
+        });
+    }
+}

package/dist/underwriting/ports/underwriting.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Port interface for bounded context: underwriting
+ */
+export interface UnderwritingInput {
+    readonly id: string;
+    readonly underwriting_id: string;
+}
+export interface Underwriting {
+    readonly id: string;
+    readonly created_at: string;
+    readonly updated_at: string;
+    readonly status: 'active' | 'inactive' | 'pending' | 'completed' | 'error';
+    readonly underwriting_id: string;
+}
+export interface UnderwritingPort {
+    /** Creates or updates underwriting record */
+    manageUnderwriting(input: UnderwritingInput): Promise<Underwriting>;
+    /** Creates or updates underwriting record */
+    queryUnderwriting(input: UnderwritingInput): Promise<Underwriting>;
+    /** Returns underwriting data */
+    listUnderwriting(input: Record<string, unknown>): Promise<Underwriting[]>;
+    /** Returns underwriting data */
+    id(input: Record<string, unknown>): Promise<Underwriting[]>;
+}

package/dist/underwriting/ports/underwriting.js

@@ -0,0 +1,2 @@
+// Generated by Phase 4 pipeline — do not edit manually
+export {};