@promptpartner/bexio-mcp-server 2.0.0

package/dist/types/schemas/orders.js

@@ -0,0 +1,101 @@
+/**
+ * Order-related Zod schemas and types.
+ * Domain: Orders (kb_order)
+ */
+import { z } from "zod";
+// Order position (line item)
+const OrderPositionSchema = z
+    .object({
+    type: z.string(),
+    text: z.string(),
+    amount: z.number(),
+    unit_id: z.number().int().positive().optional(),
+    unit_price: z.number(),
+    discount_in_percent: z.number().min(0).max(100).optional(),
+    position_total: z.number().optional(),
+    mwst_type: z.number().int().optional(),
+    mwst_is_net: z.boolean().optional(),
+    account_id: z.number().int().positive().optional(),
+    tax_id: z.number().int().positive().optional(),
+    tax_value: z.number().optional(),
+    map_all: z.boolean().optional(),
+})
+    .passthrough();
+// Order creation payload
+export const OrderCreateSchema = z
+    .object({
+    title: z.string().min(1, "Order title is required"),
+    contact_id: z.number().int().positive("Contact ID must be positive"),
+    delivery_address: z.string().optional(),
+    delivery_address_2: z.string().optional(),
+    delivery_zip: z.string().optional(),
+    delivery_city: z.string().optional(),
+    delivery_country_id: z.number().int().positive().optional(),
+    currency_id: z.number().int().positive().optional(),
+    mwst_type: z.number().int().optional(),
+    mwst_is_net: z.boolean().optional(),
+    show_position_taxes: z.boolean().optional(),
+    is_valid_from: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format")
+        .optional(),
+    is_valid_until: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format")
+        .optional(),
+    contact_address: z.string().optional(),
+    contact_address_2: z.string().optional(),
+    contact_zip: z.string().optional(),
+    contact_city: z.string().optional(),
+    contact_country_id: z.number().int().positive().optional(),
+    contact_salutation_id: z.number().int().positive().optional(),
+    contact_firstname: z.string().optional(),
+    contact_lastname: z.string().optional(),
+    contact_phone: z.string().optional(),
+    contact_mobile: z.string().optional(),
+    contact_email: z.string().email().optional(),
+    contact_website: z.string().url().optional(),
+    contact_remarks: z.string().optional(),
+    user_id: z.number().int().positive().optional(),
+    language_id: z.number().int().positive().optional(),
+    bank_account_id: z.number().int().positive().optional(),
+    payment_type_id: z.number().int().positive().optional(),
+    header: z.string().optional(),
+    footer: z.string().optional(),
+    total: z.number().optional(),
+    total_rounding_difference: z.number().optional(),
+    mwst_amount: z.number().optional(),
+    mwst_amount_net: z.number().optional(),
+    positions: z.array(OrderPositionSchema).optional(),
+})
+    .passthrough();
+// List orders
+export const ListOrdersParamsSchema = z.object({
+    limit: z.number().int().positive().default(50),
+    offset: z.number().int().min(0).default(0),
+});
+// Get single order
+export const GetOrderParamsSchema = z.object({
+    order_id: z.number().int().positive(),
+});
+// Create order
+export const CreateOrderParamsSchema = z.object({
+    order_data: OrderCreateSchema,
+});
+// Search orders
+export const SearchOrdersParamsSchema = z.object({
+    search_params: z.record(z.unknown()),
+});
+// Search by customer name
+export const SearchOrdersByCustomerParamsSchema = z.object({
+    customer_name: z.string().min(1),
+    limit: z.number().int().positive().default(50),
+});
+// Create invoice from order
+export const CreateInvoiceFromOrderParamsSchema = z.object({
+    order_id: z.number().int().positive(),
+});
+// Create delivery from order
+export const CreateDeliveryFromOrderParamsSchema = z.object({
+    order_id: z.number().int().positive(),
+});

package/dist/types/schemas/payments.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Payment-related Zod schemas and types.
+ * Domain: Payments
+ */
+import { z } from "zod";
+export declare const ListPaymentsParamsSchema: z.ZodObject<{
+    invoice_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    invoice_id: number;
+}, {
+    invoice_id: number;
+}>;
+export type ListPaymentsParams = z.infer<typeof ListPaymentsParamsSchema>;
+export declare const GetPaymentParamsSchema: z.ZodObject<{
+    invoice_id: z.ZodNumber;
+    payment_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    invoice_id: number;
+    payment_id: number;
+}, {
+    invoice_id: number;
+    payment_id: number;
+}>;
+export type GetPaymentParams = z.infer<typeof GetPaymentParamsSchema>;
+export declare const CreatePaymentParamsSchema: z.ZodObject<{
+    invoice_id: z.ZodNumber;
+    payment_data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    invoice_id: number;
+    payment_data: Record<string, unknown>;
+}, {
+    invoice_id: number;
+    payment_data: Record<string, unknown>;
+}>;
+export type CreatePaymentParams = z.infer<typeof CreatePaymentParamsSchema>;
+export declare const DeletePaymentParamsSchema: z.ZodObject<{
+    invoice_id: z.ZodNumber;
+    payment_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    invoice_id: number;
+    payment_id: number;
+}, {
+    invoice_id: number;
+    payment_id: number;
+}>;
+export type DeletePaymentParams = z.infer<typeof DeletePaymentParamsSchema>;

package/dist/types/schemas/payments.js

@@ -0,0 +1,24 @@
+/**
+ * Payment-related Zod schemas and types.
+ * Domain: Payments
+ */
+import { z } from "zod";
+// List payments for an invoice
+export const ListPaymentsParamsSchema = z.object({
+    invoice_id: z.number().int().positive(),
+});
+// Get single payment
+export const GetPaymentParamsSchema = z.object({
+    invoice_id: z.number().int().positive(),
+    payment_id: z.number().int().positive(),
+});
+// Create payment
+export const CreatePaymentParamsSchema = z.object({
+    invoice_id: z.number().int().positive(),
+    payment_data: z.record(z.unknown()),
+});
+// Delete payment
+export const DeletePaymentParamsSchema = z.object({
+    invoice_id: z.number().int().positive(),
+    payment_id: z.number().int().positive(),
+});

package/dist/types/schemas/payroll.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Payroll Zod schemas and types.
+ * Domain: Employees, Absences, and Payroll Documents
+ *
+ * IMPORTANT: Payroll module is conditional - may not be enabled in all Bexio subscriptions.
+ * Handlers check module availability on first call and cache the result.
+ * When unavailable, tools return friendly error with upgrade instructions.
+ */
+import { z } from "zod";
+export declare const ListEmployeesParamsSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListEmployeesParams = z.infer<typeof ListEmployeesParamsSchema>;
+export declare const GetEmployeeParamsSchema: z.ZodObject<{
+    employee_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    employee_id: number;
+}, {
+    employee_id: number;
+}>;
+export type GetEmployeeParams = z.infer<typeof GetEmployeeParamsSchema>;
+export declare const CreateEmployeeParamsSchema: z.ZodObject<{
+    user_id: z.ZodNumber;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    hourly_rate: z.ZodOptional<z.ZodNumber>;
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    user_id: number;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    email?: string | undefined;
+    hourly_rate?: number | undefined;
+}, {
+    user_id: number;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    email?: string | undefined;
+    hourly_rate?: number | undefined;
+}>;
+export type CreateEmployeeParams = z.infer<typeof CreateEmployeeParamsSchema>;
+export declare const UpdateEmployeeParamsSchema: z.ZodObject<{
+    employee_id: z.ZodNumber;
+    employee_data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    employee_id: number;
+    employee_data: Record<string, unknown>;
+}, {
+    employee_id: number;
+    employee_data: Record<string, unknown>;
+}>;
+export type UpdateEmployeeParams = z.infer<typeof UpdateEmployeeParamsSchema>;
+export declare const ListAbsencesParamsSchema: z.ZodObject<{
+    year: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    year?: number | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    year?: number | undefined;
+}>;
+export type ListAbsencesParams = z.infer<typeof ListAbsencesParamsSchema>;
+export declare const GetAbsenceParamsSchema: z.ZodObject<{
+    absence_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    absence_id: number;
+}, {
+    absence_id: number;
+}>;
+export type GetAbsenceParams = z.infer<typeof GetAbsenceParamsSchema>;
+export declare const CreateAbsenceParamsSchema: z.ZodObject<{
+    user_id: z.ZodNumber;
+    absence_type_id: z.ZodNumber;
+    start_date: z.ZodString;
+    end_date: z.ZodString;
+    half_day_start: z.ZodDefault<z.ZodBoolean>;
+    half_day_end: z.ZodDefault<z.ZodBoolean>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    user_id: number;
+    start_date: string;
+    end_date: string;
+    absence_type_id: number;
+    half_day_start: boolean;
+    half_day_end: boolean;
+    note?: string | undefined;
+}, {
+    user_id: number;
+    start_date: string;
+    end_date: string;
+    absence_type_id: number;
+    half_day_start?: boolean | undefined;
+    half_day_end?: boolean | undefined;
+    note?: string | undefined;
+}>;
+export type CreateAbsenceParams = z.infer<typeof CreateAbsenceParamsSchema>;
+export declare const UpdateAbsenceParamsSchema: z.ZodObject<{
+    absence_id: z.ZodNumber;
+    absence_data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    absence_id: number;
+    absence_data: Record<string, unknown>;
+}, {
+    absence_id: number;
+    absence_data: Record<string, unknown>;
+}>;
+export type UpdateAbsenceParams = z.infer<typeof UpdateAbsenceParamsSchema>;
+export declare const DeleteAbsenceParamsSchema: z.ZodObject<{
+    absence_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    absence_id: number;
+}, {
+    absence_id: number;
+}>;
+export type DeleteAbsenceParams = z.infer<typeof DeleteAbsenceParamsSchema>;
+export declare const ListPayrollDocumentsParamsSchema: z.ZodObject<{
+    employee_id: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    employee_id?: number | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    employee_id?: number | undefined;
+}>;
+export type ListPayrollDocumentsParams = z.infer<typeof ListPayrollDocumentsParamsSchema>;

package/dist/types/schemas/payroll.js

@@ -0,0 +1,65 @@
+/**
+ * Payroll Zod schemas and types.
+ * Domain: Employees, Absences, and Payroll Documents
+ *
+ * IMPORTANT: Payroll module is conditional - may not be enabled in all Bexio subscriptions.
+ * Handlers check module availability on first call and cache the result.
+ * When unavailable, tools return friendly error with upgrade instructions.
+ */
+import { z } from "zod";
+// ===== EMPLOYEES (PAY-01) =====
+export const ListEmployeesParamsSchema = z.object({
+    limit: z.number().int().positive().default(50),
+    offset: z.number().int().min(0).default(0),
+});
+export const GetEmployeeParamsSchema = z.object({
+    employee_id: z.number().int().positive(),
+});
+export const CreateEmployeeParamsSchema = z.object({
+    // Required fields
+    user_id: z.number().int().positive({ message: "User ID is required" }),
+    // Optional fields - Bexio may have more
+    first_name: z.string().min(1).optional(),
+    last_name: z.string().min(1).optional(),
+    email: z.string().email().optional(),
+    hourly_rate: z.number().positive().optional(),
+    start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD").optional(),
+    end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD").optional(),
+});
+export const UpdateEmployeeParamsSchema = z.object({
+    employee_id: z.number().int().positive(),
+    employee_data: z.record(z.unknown()),
+});
+// ===== ABSENCES (PAY-02) =====
+export const ListAbsencesParamsSchema = z.object({
+    year: z.number().int().positive().optional().describe("Filter by year (e.g., 2024)"),
+    limit: z.number().int().positive().default(50),
+    offset: z.number().int().min(0).default(0),
+});
+export const GetAbsenceParamsSchema = z.object({
+    absence_id: z.number().int().positive(),
+});
+export const CreateAbsenceParamsSchema = z.object({
+    // Required fields
+    user_id: z.number().int().positive({ message: "User ID is required" }),
+    absence_type_id: z.number().int().positive({ message: "Absence type ID is required" }),
+    start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD"),
+    end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD"),
+    // Optional fields
+    half_day_start: z.boolean().default(false).describe("True if absence starts at midday"),
+    half_day_end: z.boolean().default(false).describe("True if absence ends at midday"),
+    note: z.string().optional(),
+});
+export const UpdateAbsenceParamsSchema = z.object({
+    absence_id: z.number().int().positive(),
+    absence_data: z.record(z.unknown()),
+});
+export const DeleteAbsenceParamsSchema = z.object({
+    absence_id: z.number().int().positive(),
+});
+// ===== PAYROLL DOCUMENTS (PAY-03) =====
+export const ListPayrollDocumentsParamsSchema = z.object({
+    employee_id: z.number().int().positive().optional().describe("Filter by employee ID"),
+    limit: z.number().int().positive().default(50),
+    offset: z.number().int().min(0).default(0),
+});

package/dist/types/schemas/projects.d.ts

@@ -0,0 +1,268 @@
+/**
+ * Projects Zod schemas and types.
+ * Domain: Projects (Projects, Project Types, Project Statuses)
+ */
+import { z } from "zod";
+export declare const ListProjectsParamsSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListProjectsParams = z.infer<typeof ListProjectsParamsSchema>;
+export declare const GetProjectParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+}, {
+    project_id: number;
+}>;
+export type GetProjectParams = z.infer<typeof GetProjectParamsSchema>;
+export declare const CreateProjectParamsSchema: z.ZodObject<{
+    user_id: z.ZodNumber;
+    name: z.ZodString;
+    contact_id: z.ZodOptional<z.ZodNumber>;
+    pr_state_id: z.ZodOptional<z.ZodNumber>;
+    pr_project_type_id: z.ZodOptional<z.ZodNumber>;
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+    comment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    user_id: number;
+    contact_id?: number | undefined;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    pr_state_id?: number | undefined;
+    pr_project_type_id?: number | undefined;
+    comment?: string | undefined;
+}, {
+    name: string;
+    user_id: number;
+    contact_id?: number | undefined;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    pr_state_id?: number | undefined;
+    pr_project_type_id?: number | undefined;
+    comment?: string | undefined;
+}>;
+export type CreateProjectParams = z.infer<typeof CreateProjectParamsSchema>;
+export declare const UpdateProjectParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    project_data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+    project_data: Record<string, unknown>;
+}, {
+    project_id: number;
+    project_data: Record<string, unknown>;
+}>;
+export type UpdateProjectParams = z.infer<typeof UpdateProjectParamsSchema>;
+export declare const DeleteProjectParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+}, {
+    project_id: number;
+}>;
+export type DeleteProjectParams = z.infer<typeof DeleteProjectParamsSchema>;
+export declare const ArchiveProjectParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+}, {
+    project_id: number;
+}>;
+export type ArchiveProjectParams = z.infer<typeof ArchiveProjectParamsSchema>;
+export declare const UnarchiveProjectParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+}, {
+    project_id: number;
+}>;
+export type UnarchiveProjectParams = z.infer<typeof UnarchiveProjectParamsSchema>;
+export declare const SearchProjectsParamsSchema: z.ZodObject<{
+    search_criteria: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        criteria: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        value: string | number | boolean;
+        criteria?: string | undefined;
+    }, {
+        field: string;
+        value: string | number | boolean;
+        criteria?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    search_criteria: {
+        field: string;
+        value: string | number | boolean;
+        criteria?: string | undefined;
+    }[];
+}, {
+    search_criteria: {
+        field: string;
+        value: string | number | boolean;
+        criteria?: string | undefined;
+    }[];
+}>;
+export type SearchProjectsParams = z.infer<typeof SearchProjectsParamsSchema>;
+export declare const ListProjectTypesParamsSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListProjectTypesParams = z.infer<typeof ListProjectTypesParamsSchema>;
+export declare const GetProjectTypeParamsSchema: z.ZodObject<{
+    type_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type_id: number;
+}, {
+    type_id: number;
+}>;
+export type GetProjectTypeParams = z.infer<typeof GetProjectTypeParamsSchema>;
+export declare const ListProjectStatusesParamsSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListProjectStatusesParams = z.infer<typeof ListProjectStatusesParamsSchema>;
+export declare const GetProjectStatusParamsSchema: z.ZodObject<{
+    status_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status_id: number;
+}, {
+    status_id: number;
+}>;
+export type GetProjectStatusParams = z.infer<typeof GetProjectStatusParamsSchema>;
+export declare const ListMilestonesParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    project_id: number;
+}, {
+    project_id: number;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListMilestonesParams = z.infer<typeof ListMilestonesParamsSchema>;
+export declare const GetMilestoneParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    milestone_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+    milestone_id: number;
+}, {
+    project_id: number;
+    milestone_id: number;
+}>;
+export type GetMilestoneParams = z.infer<typeof GetMilestoneParamsSchema>;
+export declare const CreateMilestoneParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    name: z.ZodString;
+    end_date: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    project_id: number;
+    end_date?: string | undefined;
+}, {
+    name: string;
+    project_id: number;
+    end_date?: string | undefined;
+}>;
+export type CreateMilestoneParams = z.infer<typeof CreateMilestoneParamsSchema>;
+export declare const DeleteMilestoneParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    milestone_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+    milestone_id: number;
+}, {
+    project_id: number;
+    milestone_id: number;
+}>;
+export type DeleteMilestoneParams = z.infer<typeof DeleteMilestoneParamsSchema>;
+export declare const ListWorkPackagesParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    project_id: number;
+}, {
+    project_id: number;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListWorkPackagesParams = z.infer<typeof ListWorkPackagesParamsSchema>;
+export declare const GetWorkPackageParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    workpackage_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+    workpackage_id: number;
+}, {
+    project_id: number;
+    workpackage_id: number;
+}>;
+export type GetWorkPackageParams = z.infer<typeof GetWorkPackageParamsSchema>;
+export declare const CreateWorkPackageParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    name: z.ZodString;
+    estimated_time: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    project_id: number;
+    estimated_time?: string | undefined;
+}, {
+    name: string;
+    project_id: number;
+    estimated_time?: string | undefined;
+}>;
+export type CreateWorkPackageParams = z.infer<typeof CreateWorkPackageParamsSchema>;
+export declare const UpdateWorkPackageParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    workpackage_id: z.ZodNumber;
+    workpackage_data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+    workpackage_id: number;
+    workpackage_data: Record<string, unknown>;
+}, {
+    project_id: number;
+    workpackage_id: number;
+    workpackage_data: Record<string, unknown>;
+}>;
+export type UpdateWorkPackageParams = z.infer<typeof UpdateWorkPackageParamsSchema>;
+export declare const DeleteWorkPackageParamsSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    workpackage_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    project_id: number;
+    workpackage_id: number;
+}, {
+    project_id: number;
+    workpackage_id: number;
+}>;
+export type DeleteWorkPackageParams = z.infer<typeof DeleteWorkPackageParamsSchema>;