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

## 🎯 Overview

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/contracts.ts
var contracts_exports = {};
__export(contracts_exports, {
  CreateOrganisationRequestSchema: () => CreateOrganisationRequestSchema,
  CreatePersonRequestSchema: () => CreatePersonRequestSchema2,
  OrganisationContract: () => OrganisationContract,
  OrganisationListResponseSchema: () => OrganisationListResponseSchema,
  OrganisationSchema: () => OrganisationSchema,
  PersonContract: () => PersonContract,
  PersonListResponseSchema: () => PersonListResponseSchema,
  PersonSchema: () => PersonSchema,
  UpdateOrganisationRequestSchema: () => UpdateOrganisationRequestSchema,
  UpdatePersonRequestSchema: () => UpdatePersonRequestSchema,
  partyManagerApi: () => partyManagerApi
});
module.exports = __toCommonJS(contracts_exports);

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

// src/integration/contracts/person-api-contract.ts
var import_zod2 = require("zod");
var PersonRoleTypeSchema = import_zod2.z.enum([
  "Human",
  "AiAgent"
]);
var PersonSchema = import_zod2.z.object({
  // Identity
  partyId: import_zod2.z.string().uuid(),
  // Names
  firstName: import_zod2.z.string().min(1),
  lastName: import_zod2.z.string().min(1),
  displayName: import_zod2.z.string().optional(),
  // Contact
  email: import_zod2.z.string().email(),
  phone: import_zod2.z.string().optional(),
  // Classification
  roleType: PersonRoleTypeSchema,
  // Professional
  jobTitle: import_zod2.z.string().optional(),
  department: import_zod2.z.string().optional(),
  organizationId: import_zod2.z.string().uuid().optional(),
  organizationName: import_zod2.z.string().optional(),
  managerId: import_zod2.z.string().uuid().optional(),
  managerName: import_zod2.z.string().optional(),
  // Status
  isActive: import_zod2.z.boolean().default(true),
  // Metrics
  directReportsCount: import_zod2.z.number().int().min(0).default(0),
  // Security
  mfaEnabled: import_zod2.z.boolean().default(false),
  accountLocked: import_zod2.z.boolean().default(false),
  // Timestamps
  createdAt: import_zod2.z.string().datetime(),
  updatedAt: import_zod2.z.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: import_zod2.z.object({
    organizationId: import_zod2.z.string().uuid(),
    organizationName: import_zod2.z.string(),
    organizationType: import_zod2.z.string(),
    department: import_zod2.z.string().optional()
  }).optional(),
  // Management hierarchy
  managementInfo: import_zod2.z.object({
    managerId: import_zod2.z.string().uuid().optional(),
    managerName: import_zod2.z.string().optional(),
    directReports: import_zod2.z.array(import_zod2.z.object({
      partyId: import_zod2.z.string().uuid(),
      displayName: import_zod2.z.string(),
      jobTitle: import_zod2.z.string().optional()
    }))
  }).optional(),
  // Security profile
  securityProfile: import_zod2.z.object({
    mfaEnabled: import_zod2.z.boolean(),
    accountLocked: import_zod2.z.boolean(),
    failedLoginAttempts: import_zod2.z.number().int().min(0),
    lastLoginAt: import_zod2.z.string().datetime().optional(),
    totalLoginCount: import_zod2.z.number().int().min(0)
  }).optional()
});
var PersonSearchCriteriaSchema = import_zod2.z.object({
  // Pagination
  page: import_zod2.z.number().int().min(1).default(1),
  limit: import_zod2.z.number().int().min(1).max(100).default(10),
  // Filters
  searchTerm: import_zod2.z.string().optional(),
  email: import_zod2.z.string().optional(),
  firstName: import_zod2.z.string().optional(),
  lastName: import_zod2.z.string().optional(),
  roleType: PersonRoleTypeSchema.optional(),
  isActive: import_zod2.z.boolean().optional(),
  department: import_zod2.z.string().optional(),
  jobTitle: import_zod2.z.string().optional(),
  organizationId: import_zod2.z.string().uuid().optional(),
  managerId: import_zod2.z.string().uuid().optional(),
  // Sorting
  sortBy: import_zod2.z.enum([
    "firstName",
    "lastName",
    "email",
    "createdAt",
    "updatedAt",
    "department"
  ]).default("firstName"),
  sortOrder: import_zod2.z.enum([
    "asc",
    "desc"
  ]).default("asc")
});
var PersonListResponseSchema = import_zod2.z.object({
  success: import_zod2.z.boolean(),
  data: import_zod2.z.array(PersonListItemSchema),
  metadata: import_zod2.z.object({
    total: import_zod2.z.number().int().min(0),
    page: import_zod2.z.number().int().min(1),
    limit: import_zod2.z.number().int().min(1),
    hasMore: import_zod2.z.boolean()
  }),
  timestamp: import_zod2.z.string().datetime()
});
var PersonDetailResponseSchema = import_zod2.z.object({
  success: import_zod2.z.boolean(),
  data: PersonDetailSchema,
  timestamp: import_zod2.z.string().datetime()
});
var CreatePersonRequestSchema2 = import_zod2.z.object({
  firstName: import_zod2.z.string().min(1),
  lastName: import_zod2.z.string().min(1),
  email: import_zod2.z.string().email(),
  roleType: PersonRoleTypeSchema,
  phone: import_zod2.z.string().optional(),
  jobTitle: import_zod2.z.string().optional(),
  department: import_zod2.z.string().optional(),
  organizationId: import_zod2.z.string().uuid().optional(),
  managerId: import_zod2.z.string().uuid().optional()
});
var UpdatePersonRequestSchema = CreatePersonRequestSchema2.partial();
var PersonErrorResponseSchema = import_zod2.z.object({
  success: import_zod2.z.literal(false),
  error: import_zod2.z.object({
    code: import_zod2.z.string(),
    message: import_zod2.z.string(),
    details: import_zod2.z.any().optional()
  }),
  timestamp: import_zod2.z.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: import_zod2.z.object({
      partyId: import_zod2.z.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: import_zod2.z.object({
      partyId: import_zod2.z.string().uuid()
    }),
    body: UpdatePersonRequestSchema,
    response: PersonDetailResponseSchema,
    errorResponse: PersonErrorResponseSchema
  },
  /**
  * Delete person (soft delete)
  */
  delete: {
    method: "DELETE",
    path: "/api/party/persons/:partyId",
    params: import_zod2.z.object({
      partyId: import_zod2.z.string().uuid()
    }),
    response: import_zod2.z.object({
      success: import_zod2.z.boolean(),
      message: import_zod2.z.string(),
      timestamp: import_zod2.z.string().datetime()
    }),
    errorResponse: PersonErrorResponseSchema
  }
};

// src/integration/contracts/organisation-api-contract.ts
var import_zod3 = require("zod");
var OrganisationTypeSchema = import_zod3.z.enum([
  "Corporation",
  "LLC",
  "Partnership",
  "SoleProprietorship",
  "NonProfit",
  "Government",
  "Other"
]);
var OrganisationSizeSchema = import_zod3.z.enum([
  "Micro",
  "Small",
  "Medium",
  "Large",
  "Enterprise"
  // 1000+ employees
]);
var OrganisationSchema = import_zod3.z.object({
  // Identity
  partyId: import_zod3.z.string().uuid(),
  // Names - simplified from complex DDD structure
  name: import_zod3.z.string().min(1),
  legalName: import_zod3.z.string().min(1),
  tradingName: import_zod3.z.string().optional(),
  // Classification
  organisationType: OrganisationTypeSchema,
  organisationSize: OrganisationSizeSchema,
  industry: import_zod3.z.string().optional(),
  // Details
  description: import_zod3.z.string().optional(),
  website: import_zod3.z.string().url().optional(),
  contactEmail: import_zod3.z.string().email().optional(),
  foundedYear: import_zod3.z.number().int().min(1800).max((/* @__PURE__ */ new Date()).getFullYear()).optional(),
  // Location
  headquarters: import_zod3.z.string().optional(),
  // Metrics
  employeeCount: import_zod3.z.number().int().min(0).optional(),
  revenue: import_zod3.z.number().min(0).optional(),
  stockSymbol: import_zod3.z.string().optional(),
  // Relationships
  parentOrganisationId: import_zod3.z.string().uuid().optional(),
  parentOrganisationName: import_zod3.z.string().optional(),
  subsidiaryCount: import_zod3.z.number().int().min(0).default(0),
  // Status
  isActive: import_zod3.z.boolean().default(true),
  // Timestamps
  createdAt: import_zod3.z.string().datetime(),
  updatedAt: import_zod3.z.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: import_zod3.z.object({
    totalEmployees: import_zod3.z.number().int().min(0),
    recentHires: import_zod3.z.number().int().min(0),
    departmentBreakdown: import_zod3.z.array(import_zod3.z.object({
      department: import_zod3.z.string(),
      count: import_zod3.z.number().int().min(0)
    }))
  }).optional(),
  // Data quality indicator
  dataCompleteness: import_zod3.z.object({
    percentage: import_zod3.z.number().min(0).max(100),
    missingFields: import_zod3.z.array(import_zod3.z.string())
  }).optional()
});
var OrganisationSearchCriteriaSchema = import_zod3.z.object({
  // Pagination
  page: import_zod3.z.number().int().min(1).default(1),
  limit: import_zod3.z.number().int().min(1).max(100).default(10),
  // Filters
  searchTerm: import_zod3.z.string().optional(),
  organisationType: OrganisationTypeSchema.optional(),
  organisationSize: OrganisationSizeSchema.optional(),
  industry: import_zod3.z.string().optional(),
  isActive: import_zod3.z.boolean().optional(),
  parentOrganisationId: import_zod3.z.string().uuid().optional(),
  // Sorting
  sortBy: import_zod3.z.enum([
    "name",
    "legalName",
    "createdAt",
    "updatedAt",
    "employeeCount"
  ]).default("name"),
  sortOrder: import_zod3.z.enum([
    "asc",
    "desc"
  ]).default("asc")
});
var OrganisationListResponseSchema = import_zod3.z.object({
  success: import_zod3.z.boolean(),
  data: import_zod3.z.array(OrganisationListItemSchema),
  metadata: import_zod3.z.object({
    total: import_zod3.z.number().int().min(0),
    page: import_zod3.z.number().int().min(1),
    limit: import_zod3.z.number().int().min(1),
    hasMore: import_zod3.z.boolean()
  }),
  timestamp: import_zod3.z.string().datetime()
});
var OrganisationDetailResponseSchema = import_zod3.z.object({
  success: import_zod3.z.boolean(),
  data: OrganisationDetailSchema,
  timestamp: import_zod3.z.string().datetime()
});
var CreateOrganisationRequestSchema = import_zod3.z.object({
  legalName: import_zod3.z.string().min(1),
  tradingName: import_zod3.z.string().optional(),
  organisationType: OrganisationTypeSchema,
  organisationSize: OrganisationSizeSchema,
  industry: import_zod3.z.string().optional(),
  description: import_zod3.z.string().optional(),
  website: import_zod3.z.string().url().optional(),
  contactEmail: import_zod3.z.string().email().optional(),
  foundedYear: import_zod3.z.number().int().min(1800).max((/* @__PURE__ */ new Date()).getFullYear()).optional(),
  headquarters: import_zod3.z.string().optional(),
  employeeCount: import_zod3.z.number().int().min(0).optional()
});
var UpdateOrganisationRequestSchema = CreateOrganisationRequestSchema.partial();
var OrganisationErrorResponseSchema = import_zod3.z.object({
  success: import_zod3.z.literal(false),
  error: import_zod3.z.object({
    code: import_zod3.z.string(),
    message: import_zod3.z.string(),
    details: import_zod3.z.any().optional()
  }),
  timestamp: import_zod3.z.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: import_zod3.z.object({
      partyId: import_zod3.z.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: import_zod3.z.object({
      partyId: import_zod3.z.string().uuid()
    }),
    body: UpdateOrganisationRequestSchema,
    response: OrganisationDetailResponseSchema,
    errorResponse: OrganisationErrorResponseSchema
  },
  /**
  * Delete organisation (soft delete)
  */
  delete: {
    method: "DELETE",
    path: "/api/party/organisations/:partyId",
    params: import_zod3.z.object({
      partyId: import_zod3.z.string().uuid()
    }),
    response: import_zod3.z.object({
      success: import_zod3.z.boolean(),
      message: import_zod3.z.string(),
      timestamp: import_zod3.z.string().datetime()
    }),
    errorResponse: OrganisationErrorResponseSchema
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  CreateOrganisationRequestSchema,
  CreatePersonRequestSchema,
  OrganisationContract,
  OrganisationListResponseSchema,
  OrganisationSchema,
  PersonContract,
  PersonListResponseSchema,
  PersonSchema,
  UpdateOrganisationRequestSchema,
  UpdatePersonRequestSchema,
  partyManagerApi
});
//# sourceMappingURL=contracts.js.map