@simpleapps-com/augur-api/dist/esm/services/joomla/schemas/users.js

TypeScript client library for Augur microservices API endpoints

import { z } from 'zod';
import { BaseResponseSchema, BaseGetParamsSchema } from '../../../core/schemas';
import { flexibleUserFields } from '../../../core/flexible-schemas';
// User schemas - based on actual API response
export const UserSchema = z.object({
    id: z.number(),
    username: z.string().min(1, 'Username cannot be empty'),
    email: z.string().email('Invalid email format'),
    name: z.string(),
    registerDate: z.string(),
    lastvisitDate: z.string(),
    lastResetTime: z.string().optional(),
    activation: z.string().optional(),
    block: z.number().optional(),
    timezone: z.string().optional(),
    language: z.string().optional(),
    customerId: z.string().optional(),
    contactId: z.string().optional(),
    profileValues: flexibleUserFields.profileValues, // Handles both object and array formats
    groups: flexibleUserFields.groups, // Handles various group data formats
});
export const UserListParamsSchema = BaseGetParamsSchema.extend({
    limit: z.number().optional().default(10),
    offset: z.number().optional().default(0),
    orderBy: z.string().optional(),
    q: z.string().optional(),
});
// Response schemas using BaseResponseSchema (8-field format)
export const UserListResponseSchema = BaseResponseSchema(z.array(UserSchema));
export const UserResponseSchema = BaseResponseSchema(z.union([
    UserSchema,
    z.boolean(), // False when user is not found
]));
// Password verification schemas
export const VerifyPasswordRequestSchema = z.object({
    username: z.string().min(1, 'Username is required'),
    password: z.string().min(1, 'Password is required'),
    siteId: z.string().optional(), // Optional site ID override for cross-site authentication
});
export const VerifyPasswordDataSchema = z.object({
    id: z.number(),
    isVerified: z.boolean(),
    username: z.string(),
    token: z.union([z.string(), z.boolean()]), // string when verified, false when not
    email: z.string(),
});
export const VerifyPasswordResponseSchema = BaseResponseSchema(VerifyPasswordDataSchema);
// User document schemas
export const UserDocumentDataSchema = z.union([
    z.object({
        id: z.number(),
        name: z.string(),
        username: z.string(),
        email: z.string(),
        block: z.number(),
        registerDate: z.string(),
        lastvisitDate: z.string(),
        lastResetTime: z.string(),
        timezone: z.string(),
        language: z.string(),
        customerId: z.string(),
        contactId: z.string(),
        profileValues: z.record(z.union([z.string(), z.array(z.string())])),
        groups: z.array(z
            .object({
            id: z.number(),
            title: z.string(),
        })
            .passthrough()),
    }),
    z.boolean(), // False when user not found or access denied
]);
export const UserDocumentResponseSchema = BaseResponseSchema(UserDocumentDataSchema);
// Trinity user doc schemas
export const TrinityDocParamsSchema = BaseGetParamsSchema.extend({
    limit: z.number().optional().default(10),
    offset: z.number().optional().default(0),
    orderBy: z.string().optional(),
    q: z.string().optional(),
});
export const TrinityDocDataSchema = z.object({
    profile: z.object({
        id: z.number(),
        name: z.string(),
        username: z.string(),
        email: z.string(),
        lastvisitDate: z.string(),
        registerDate: z.string(),
        block: z.number(),
        contactId: z.union([z.number(), z.null()]),
        customerId: z.union([z.number(), z.null()]),
        contractNo: z.union([z.string(), z.null()]),
        shipTo: z.union([z.string(), z.null()]),
        phone: z.union([z.string(), z.null()]),
        title: z.union([z.string(), z.null()]),
        companyName: z.union([z.string(), z.null()]),
        approved: z.union([z.number(), z.null()]),
    }),
    p21Role: z.union([
        z.object({
            contactRoleUid: z.number(),
            contactRoleId: z.number(),
            contactRoleName: z.string(),
            parentName: z.string(),
            parentGroupId: z.number(),
            groupId: z.number(),
            id: z.number(),
            address: z
                .object({
                physState: z.union([z.string(), z.null()]),
                mailState: z.union([z.string(), z.null()]),
            })
                .passthrough(), // Allow additional properties
        }),
        z.null(),
    ]),
    groups: z.array(z
        .object({
        id: z.number(),
        title: z.string(),
    })
        .passthrough() // Allow additional properties like level
    ),
    territory: z.string(),
    role: z.string(),
});
export const TrinityDocResponseSchema = BaseResponseSchema(TrinityDocDataSchema).and(z.object({
    runTime: z.number().optional(),
}));
// User creation schemas - using request body (OpenAPI spec incomplete for this endpoint)
export const CreateUserRequestSchema = z.object({
    username: z.string().min(1, 'Username is required').max(150),
    email: z.string().email('Valid email is required').max(100),
    name: z.string().optional(),
    password: z.string().optional(),
    groups: z.array(z.number()).optional(),
    profileValues: z.record(z.string()).optional(),
});
export const CreateUserResponseSchema = BaseResponseSchema(z.object({
    id: z.number(),
    username: z.string(),
    email: z.string(),
    name: z.string(),
}));
// User update schemas
export const UpdateUserRequestSchema = z.object({
    name: z.string().max(400).optional(),
    username: z.string().max(150).optional(),
    email: z.string().email().max(100).optional(),
    password: z.string().max(100).optional(),
    profileValues: z.record(z.union([z.string(), z.array(z.string())])).optional(),
});
export const UpdateUserResponseSchema = BaseResponseSchema(z.boolean());
// Block user response schema
export const BlockUserResponseSchema = BaseResponseSchema(z.boolean());
//# sourceMappingURL=users.js.map