@swoft/party-manager/dist/contracts.mjs

## 🎯 Overview

// src/integration/contracts/zodios-api.ts
import { makeApi } from "@zodios/core";
import { z } from "zod";
var PersonSummarySchema = z.object({
  personId: z.string().describe("Unique person identifier"),
  email: z.string().email().describe("Person email address"),
  firstName: z.string().describe("Person first name"),
  lastName: z.string().describe("Person last name"),
  displayName: z.string().describe("Person display name"),
  roleType: z.enum([
    "Human",
    "AiAgent"
  ]).describe("Type of person"),
  isActive: z.boolean().describe("Whether person is active"),
  contactInfo: z.object({
    phone: z.string().optional(),
    preferredName: z.string().optional()
  }),
  professionalInfo: z.object({
    department: z.string().optional(),
    jobTitle: z.string().optional(),
    managerId: z.string().optional(),
    managerName: z.string().optional(),
    location: z.string().optional(),
    hireDate: z.string().optional()
    // ISO date
  }),
  organizationContext: z.object({
    organizationId: z.string(),
    organizationName: z.string(),
    organizationType: z.string()
  }).optional(),
  profileMetrics: z.object({
    directReportsCount: z.number(),
    accountCreatedAt: z.string(),
    lastLoginAt: z.string().optional(),
    totalLoginCount: z.number()
  }),
  securityProfile: z.object({
    mfaEnabled: z.boolean(),
    accountLocked: z.boolean(),
    failedLoginAttempts: z.number(),
    lastPasswordChange: z.string().optional()
  }),
  auditInfo: z.object({
    createdAt: z.string(),
    updatedAt: z.string()
  })
});
var PersonQueryCriteriaSchema = z.object({
  searchTerm: z.string().optional().describe("Search across name, email, and other text fields"),
  email: z.string().optional().describe("Exact email match"),
  firstName: z.string().optional().describe("Exact or partial first name"),
  lastName: z.string().optional().describe("Exact or partial last name"),
  roleType: z.enum([
    "Human",
    "AiAgent",
    "all"
  ]).optional(),
  isActive: z.boolean().optional(),
  department: z.string().optional(),
  jobTitle: z.string().optional(),
  managerId: z.string().optional(),
  organizationId: z.string().optional(),
  hasManager: z.boolean().optional(),
  hasDirectReports: z.boolean().optional(),
  locationFilter: z.object({
    country: z.string().optional(),
    region: z.string().optional(),
    city: z.string().optional()
  }).optional(),
  securityFilters: z.object({
    mfaEnabled: z.boolean().optional(),
    accountLocked: z.boolean().optional(),
    hasFailedLogins: z.boolean().optional(),
    passwordExpired: z.boolean().optional()
  }).optional(),
  pagination: z.object({
    limit: z.number().optional(),
    offset: z.number().optional(),
    sortBy: z.enum([
      "name",
      "email",
      "createdAt",
      "lastLogin",
      "department"
    ]).optional(),
    sortOrder: z.enum([
      "asc",
      "desc"
    ]).optional()
  }).optional()
});
var CreatePersonRequestSchema = z.object({
  email: z.string().email().describe("Person email address"),
  firstName: z.string().describe("Person first name"),
  lastName: z.string().describe("Person last name"),
  roleType: z.enum([
    "Human",
    "AiAgent"
  ]).describe("Type of person"),
  organizationId: z.string().optional().describe("Organization ID"),
  departmentId: z.string().optional().describe("Department ID"),
  jobTitle: z.string().optional().describe("Job title"),
  managerId: z.string().optional().describe("Manager person ID"),
  contactInfo: z.object({
    phone: z.string().optional(),
    preferredName: z.string().optional()
  }).optional()
});
var OrganizationSummarySchema = z.object({
  organizationId: z.string().describe("Unique organization identifier"),
  legalName: z.string().describe("Legal organization name"),
  displayName: z.string().optional().describe("Display name"),
  tradingName: z.string().optional().describe("Trading name"),
  businessProfile: z.object({
    industry: z.string(),
    organizationType: z.string(),
    organizationSize: z.enum([
      "startup",
      "small",
      "medium",
      "large",
      "enterprise"
    ]),
    foundedYear: z.number().optional()
  }),
  contactDetails: z.object({
    primaryEmail: z.string().optional(),
    primaryPhone: z.string().optional(),
    website: z.string().optional()
  }),
  locationInfo: z.object({
    headquartersCountry: z.string().optional(),
    headquartersRegion: z.string().optional(),
    headquartersCity: z.string().optional(),
    operatingRegions: z.array(z.string())
  }),
  employeeMetrics: z.object({
    totalEmployees: z.number(),
    humanEmployees: z.number(),
    aiAgents: z.number(),
    recentHires: z.number(),
    departmentCount: z.number()
  }),
  operationalStatus: z.object({
    isActive: z.boolean(),
    operationalSince: z.string().optional(),
    lastActivityDate: z.string().optional()
  }),
  auditInfo: z.object({
    createdAt: z.string(),
    updatedAt: z.string()
  })
});
var OrganizationQueryCriteriaSchema = z.object({
  searchTerm: z.string().optional(),
  legalName: z.string().optional(),
  industry: z.string().optional(),
  organizationType: z.string().optional(),
  organizationSize: z.enum([
    "startup",
    "small",
    "medium",
    "large",
    "enterprise",
    "all"
  ]).optional(),
  isActive: z.boolean().optional(),
  pagination: z.object({
    limit: z.number().optional(),
    offset: z.number().optional(),
    sortBy: z.enum([
      "name",
      "industry",
      "size",
      "createdAt",
      "employeeCount"
    ]).optional(),
    sortOrder: z.enum([
      "asc",
      "desc"
    ]).optional()
  }).optional()
});
var AuthenticationSummarySchema = z.object({
  personId: z.string(),
  authenticationId: z.string(),
  email: z.string(),
  accountStatus: z.object({
    status: z.enum([
      "active",
      "locked",
      "suspended",
      "pending_activation"
    ]),
    isEmailVerified: z.boolean(),
    accountCreationDate: z.string(),
    lastStatusChange: z.string().optional()
  }),
  sessionMetrics: z.object({
    hasActiveSession: z.boolean(),
    activeSessionCount: z.number(),
    lastLoginAt: z.string().optional(),
    lastLoginIP: z.string().optional(),
    totalLoginCount: z.number(),
    averageSessionDuration: z.number()
  }),
  securitySettings: z.object({
    mfaEnabled: z.boolean(),
    mfaMethod: z.enum([
      "totp",
      "sms",
      "email"
    ]).optional(),
    passwordLastChanged: z.string().optional(),
    passwordStrength: z.enum([
      "weak",
      "medium",
      "strong"
    ]),
    failedLoginAttempts: z.number(),
    lockoutExpiresAt: z.string().optional()
  }),
  auditInfo: z.object({
    createdAt: z.string(),
    updatedAt: z.string()
  })
});
var partyManagerApi = makeApi([
  // Person Management
  {
    method: "get",
    path: "/api/persons",
    alias: "getPersons",
    description: "Get persons with optional filtering and pagination",
    parameters: [
      {
        name: "query",
        type: "Query",
        schema: PersonQueryCriteriaSchema
      }
    ],
    response: z.object({
      items: z.array(PersonSummarySchema),
      total: z.number(),
      hasMore: z.boolean(),
      pagination: z.object({
        limit: z.number(),
        offset: z.number(),
        totalPages: z.number()
      })
    })
  },
  {
    method: "get",
    path: "/api/persons/:id",
    alias: "getPerson",
    description: "Get a specific person by ID",
    parameters: [
      {
        name: "id",
        type: "Path",
        schema: z.string()
      }
    ],
    response: PersonSummarySchema
  },
  {
    method: "post",
    path: "/api/persons",
    alias: "createPerson",
    description: "Create a new person",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: CreatePersonRequestSchema
      }
    ],
    response: PersonSummarySchema
  },
  {
    method: "put",
    path: "/api/persons/:id",
    alias: "updatePerson",
    description: "Update an existing person",
    parameters: [
      {
        name: "id",
        type: "Path",
        schema: z.string()
      },
      {
        name: "body",
        type: "Body",
        schema: CreatePersonRequestSchema.partial()
      }
    ],
    response: PersonSummarySchema
  },
  // Organization Management
  {
    method: "get",
    path: "/api/organizations",
    alias: "getOrganizations",
    description: "Get organizations with optional filtering",
    parameters: [
      {
        name: "query",
        type: "Query",
        schema: OrganizationQueryCriteriaSchema
      }
    ],
    response: z.object({
      items: z.array(OrganizationSummarySchema),
      total: z.number(),
      hasMore: z.boolean()
    })
  },
  {
    method: "get",
    path: "/api/organizations/:id",
    alias: "getOrganization",
    description: "Get a specific organization by ID",
    parameters: [
      {
        name: "id",
        type: "Path",
        schema: z.string()
      }
    ],
    response: OrganizationSummarySchema
  },
  // Authentication Management
  {
    method: "get",
    path: "/api/authentication",
    alias: "getAuthenticationRecords",
    description: "Get authentication records for security analysis",
    parameters: [
      {
        name: "query",
        type: "Query",
        schema: z.object({
          personId: z.string().optional(),
          email: z.string().optional(),
          accountStatus: z.enum([
            "active",
            "locked",
            "suspended",
            "pending_activation",
            "all"
          ]).optional(),
          organizationId: z.string().optional(),
          limit: z.number().optional(),
          offset: z.number().optional()
        })
      }
    ],
    response: z.object({
      items: z.array(AuthenticationSummarySchema),
      total: z.number(),
      hasMore: z.boolean()
    })
  },
  {
    method: "get",
    path: "/api/authentication/:personId",
    alias: "getAuthenticationByPerson",
    description: "Get authentication record for a specific person",
    parameters: [
      {
        name: "personId",
        type: "Path",
        schema: z.string()
      }
    ],
    response: AuthenticationSummarySchema
  },
  // Health/Status endpoints
  {
    method: "get",
    path: "/api/party-manager/health",
    alias: "getHealthStatus",
    description: "Get Party Manager domain health status",
    response: z.object({
      status: z.enum([
        "healthy",
        "degraded",
        "unhealthy"
      ]),
      version: z.string(),
      timestamp: z.string(),
      checks: z.object({
        database: z.boolean(),
        authentication: z.boolean(),
        cache: z.boolean()
      })
    })
  }
]);

// src/integration/contracts/person-api-contract.ts
import { z as z2 } from "zod";
var PersonRoleTypeSchema = z2.enum([
  "Human",
  "AiAgent"
]);
var PersonSchema = z2.object({
  // Identity
  partyId: z2.string().uuid(),
  // Names
  firstName: z2.string().min(1),
  lastName: z2.string().min(1),
  displayName: z2.string().optional(),
  // Contact
  email: z2.string().email(),
  phone: z2.string().optional(),
  // Classification
  roleType: PersonRoleTypeSchema,
  // Professional
  jobTitle: z2.string().optional(),
  department: z2.string().optional(),
  organizationId: z2.string().uuid().optional(),
  organizationName: z2.string().optional(),
  managerId: z2.string().uuid().optional(),
  managerName: z2.string().optional(),
  // Status
  isActive: z2.boolean().default(true),
  // Metrics
  directReportsCount: z2.number().int().min(0).default(0),
  // Security
  mfaEnabled: z2.boolean().default(false),
  accountLocked: z2.boolean().default(false),
  // Timestamps
  createdAt: z2.string().datetime(),
  updatedAt: z2.string().datetime()
});
var PersonListItemSchema = PersonSchema.pick({
  partyId: true,
  firstName: true,
  lastName: true,
  email: true,
  roleType: true,
  jobTitle: true,
  department: true,
  isActive: true,
  organizationName: true,
  createdAt: true,
  updatedAt: true
});
var PersonDetailSchema = PersonSchema.extend({
  // Full organization context
  organizationContext: z2.object({
    organizationId: z2.string().uuid(),
    organizationName: z2.string(),
    organizationType: z2.string(),
    department: z2.string().optional()
  }).optional(),
  // Management hierarchy
  managementInfo: z2.object({
    managerId: z2.string().uuid().optional(),
    managerName: z2.string().optional(),
    directReports: z2.array(z2.object({
      partyId: z2.string().uuid(),
      displayName: z2.string(),
      jobTitle: z2.string().optional()
    }))
  }).optional(),
  // Security profile
  securityProfile: z2.object({
    mfaEnabled: z2.boolean(),
    accountLocked: z2.boolean(),
    failedLoginAttempts: z2.number().int().min(0),
    lastLoginAt: z2.string().datetime().optional(),
    totalLoginCount: z2.number().int().min(0)
  }).optional()
});
var PersonSearchCriteriaSchema = z2.object({
  // Pagination
  page: z2.number().int().min(1).default(1),
  limit: z2.number().int().min(1).max(100).default(10),
  // Filters
  searchTerm: z2.string().optional(),
  email: z2.string().optional(),
  firstName: z2.string().optional(),
  lastName: z2.string().optional(),
  roleType: PersonRoleTypeSchema.optional(),
  isActive: z2.boolean().optional(),
  department: z2.string().optional(),
  jobTitle: z2.string().optional(),
  organizationId: z2.string().uuid().optional(),
  managerId: z2.string().uuid().optional(),
  // Sorting
  sortBy: z2.enum([
    "firstName",
    "lastName",
    "email",
    "createdAt",
    "updatedAt",
    "department"
  ]).default("firstName"),
  sortOrder: z2.enum([
    "asc",
    "desc"
  ]).default("asc")
});
var PersonListResponseSchema = z2.object({
  success: z2.boolean(),
  data: z2.array(PersonListItemSchema),
  metadata: z2.object({
    total: z2.number().int().min(0),
    page: z2.number().int().min(1),
    limit: z2.number().int().min(1),
    hasMore: z2.boolean()
  }),
  timestamp: z2.string().datetime()
});
var PersonDetailResponseSchema = z2.object({
  success: z2.boolean(),
  data: PersonDetailSchema,
  timestamp: z2.string().datetime()
});
var CreatePersonRequestSchema2 = z2.object({
  firstName: z2.string().min(1),
  lastName: z2.string().min(1),
  email: z2.string().email(),
  roleType: PersonRoleTypeSchema,
  phone: z2.string().optional(),
  jobTitle: z2.string().optional(),
  department: z2.string().optional(),
  organizationId: z2.string().uuid().optional(),
  managerId: z2.string().uuid().optional()
});
var UpdatePersonRequestSchema = CreatePersonRequestSchema2.partial();
var PersonErrorResponseSchema = z2.object({
  success: z2.literal(false),
  error: z2.object({
    code: z2.string(),
    message: z2.string(),
    details: z2.any().optional()
  }),
  timestamp: z2.string().datetime()
});
var PersonContract = {
  /**
  * List persons with filtering and pagination
  */
  list: {
    method: "GET",
    path: "/api/party/persons",
    queryParams: PersonSearchCriteriaSchema,
    response: PersonListResponseSchema,
    errorResponse: PersonErrorResponseSchema
  },
  /**
  * Get single person by ID
  */
  get: {
    method: "GET",
    path: "/api/party/persons/:partyId",
    params: z2.object({
      partyId: z2.string().uuid()
    }),
    response: PersonDetailResponseSchema,
    errorResponse: PersonErrorResponseSchema
  },
  /**
  * Create new person
  */
  create: {
    method: "POST",
    path: "/api/party/persons",
    body: CreatePersonRequestSchema2,
    response: PersonDetailResponseSchema,
    errorResponse: PersonErrorResponseSchema
  },
  /**
  * Update existing person
  */
  update: {
    method: "PUT",
    path: "/api/party/persons/:partyId",
    params: z2.object({
      partyId: z2.string().uuid()
    }),
    body: UpdatePersonRequestSchema,
    response: PersonDetailResponseSchema,
    errorResponse: PersonErrorResponseSchema
  },
  /**
  * Delete person (soft delete)
  */
  delete: {
    method: "DELETE",
    path: "/api/party/persons/:partyId",
    params: z2.object({
      partyId: z2.string().uuid()
    }),
    response: z2.object({
      success: z2.boolean(),
      message: z2.string(),
      timestamp: z2.string().datetime()
    }),
    errorResponse: PersonErrorResponseSchema
  }
};

// src/integration/contracts/organisation-api-contract.ts
import { z as z3 } from "zod";
var OrganisationTypeSchema = z3.enum([
  "Corporation",
  "LLC",
  "Partnership",
  "SoleProprietorship",
  "NonProfit",
  "Government",
  "Other"
]);
var OrganisationSizeSchema = z3.enum([
  "Micro",
  "Small",
  "Medium",
  "Large",
  "Enterprise"
  // 1000+ employees
]);
var OrganisationSchema = z3.object({
  // Identity
  partyId: z3.string().uuid(),
  // Names - simplified from complex DDD structure
  name: z3.string().min(1),
  legalName: z3.string().min(1),
  tradingName: z3.string().optional(),
  // Classification
  organisationType: OrganisationTypeSchema,
  organisationSize: OrganisationSizeSchema,
  industry: z3.string().optional(),
  // Details
  description: z3.string().optional(),
  website: z3.string().url().optional(),
  contactEmail: z3.string().email().optional(),
  foundedYear: z3.number().int().min(1800).max((/* @__PURE__ */ new Date()).getFullYear()).optional(),
  // Location
  headquarters: z3.string().optional(),
  // Metrics
  employeeCount: z3.number().int().min(0).optional(),
  revenue: z3.number().min(0).optional(),
  stockSymbol: z3.string().optional(),
  // Relationships
  parentOrganisationId: z3.string().uuid().optional(),
  parentOrganisationName: z3.string().optional(),
  subsidiaryCount: z3.number().int().min(0).default(0),
  // Status
  isActive: z3.boolean().default(true),
  // Timestamps
  createdAt: z3.string().datetime(),
  updatedAt: z3.string().datetime()
});
var OrganisationListItemSchema = OrganisationSchema.pick({
  partyId: true,
  name: true,
  legalName: true,
  organisationType: true,
  organisationSize: true,
  industry: true,
  isActive: true,
  headquarters: true,
  employeeCount: true,
  createdAt: true,
  updatedAt: true
});
var OrganisationDetailSchema = OrganisationSchema.extend({
  // Employee statistics
  employeeStats: z3.object({
    totalEmployees: z3.number().int().min(0),
    recentHires: z3.number().int().min(0),
    departmentBreakdown: z3.array(z3.object({
      department: z3.string(),
      count: z3.number().int().min(0)
    }))
  }).optional(),
  // Data quality indicator
  dataCompleteness: z3.object({
    percentage: z3.number().min(0).max(100),
    missingFields: z3.array(z3.string())
  }).optional()
});
var OrganisationSearchCriteriaSchema = z3.object({
  // Pagination
  page: z3.number().int().min(1).default(1),
  limit: z3.number().int().min(1).max(100).default(10),
  // Filters
  searchTerm: z3.string().optional(),
  organisationType: OrganisationTypeSchema.optional(),
  organisationSize: OrganisationSizeSchema.optional(),
  industry: z3.string().optional(),
  isActive: z3.boolean().optional(),
  parentOrganisationId: z3.string().uuid().optional(),
  // Sorting
  sortBy: z3.enum([
    "name",
    "legalName",
    "createdAt",
    "updatedAt",
    "employeeCount"
  ]).default("name"),
  sortOrder: z3.enum([
    "asc",
    "desc"
  ]).default("asc")
});
var OrganisationListResponseSchema = z3.object({
  success: z3.boolean(),
  data: z3.array(OrganisationListItemSchema),
  metadata: z3.object({
    total: z3.number().int().min(0),
    page: z3.number().int().min(1),
    limit: z3.number().int().min(1),
    hasMore: z3.boolean()
  }),
  timestamp: z3.string().datetime()
});
var OrganisationDetailResponseSchema = z3.object({
  success: z3.boolean(),
  data: OrganisationDetailSchema,
  timestamp: z3.string().datetime()
});
var CreateOrganisationRequestSchema = z3.object({
  legalName: z3.string().min(1),
  tradingName: z3.string().optional(),
  organisationType: OrganisationTypeSchema,
  organisationSize: OrganisationSizeSchema,
  industry: z3.string().optional(),
  description: z3.string().optional(),
  website: z3.string().url().optional(),
  contactEmail: z3.string().email().optional(),
  foundedYear: z3.number().int().min(1800).max((/* @__PURE__ */ new Date()).getFullYear()).optional(),
  headquarters: z3.string().optional(),
  employeeCount: z3.number().int().min(0).optional()
});
var UpdateOrganisationRequestSchema = CreateOrganisationRequestSchema.partial();
var OrganisationErrorResponseSchema = z3.object({
  success: z3.literal(false),
  error: z3.object({
    code: z3.string(),
    message: z3.string(),
    details: z3.any().optional()
  }),
  timestamp: z3.string().datetime()
});
var OrganisationContract = {
  /**
  * List organisations with filtering and pagination
  */
  list: {
    method: "GET",
    path: "/api/party/organisations",
    queryParams: OrganisationSearchCriteriaSchema,
    response: OrganisationListResponseSchema,
    errorResponse: OrganisationErrorResponseSchema
  },
  /**
  * Get single organisation by ID
  */
  get: {
    method: "GET",
    path: "/api/party/organisations/:partyId",
    params: z3.object({
      partyId: z3.string().uuid()
    }),
    response: OrganisationDetailResponseSchema,
    errorResponse: OrganisationErrorResponseSchema
  },
  /**
  * Create new organisation
  */
  create: {
    method: "POST",
    path: "/api/party/organisations",
    body: CreateOrganisationRequestSchema,
    response: OrganisationDetailResponseSchema,
    errorResponse: OrganisationErrorResponseSchema
  },
  /**
  * Update existing organisation
  */
  update: {
    method: "PUT",
    path: "/api/party/organisations/:partyId",
    params: z3.object({
      partyId: z3.string().uuid()
    }),
    body: UpdateOrganisationRequestSchema,
    response: OrganisationDetailResponseSchema,
    errorResponse: OrganisationErrorResponseSchema
  },
  /**
  * Delete organisation (soft delete)
  */
  delete: {
    method: "DELETE",
    path: "/api/party/organisations/:partyId",
    params: z3.object({
      partyId: z3.string().uuid()
    }),
    response: z3.object({
      success: z3.boolean(),
      message: z3.string(),
      timestamp: z3.string().datetime()
    }),
    errorResponse: OrganisationErrorResponseSchema
  }
};
export {
  CreateOrganisationRequestSchema,
  CreatePersonRequestSchema2 as CreatePersonRequestSchema,
  OrganisationContract,
  OrganisationListResponseSchema,
  OrganisationSchema,
  PersonContract,
  PersonListResponseSchema,
  PersonSchema,
  UpdateOrganisationRequestSchema,
  UpdatePersonRequestSchema,
  partyManagerApi
};
//# sourceMappingURL=contracts.mjs.map