import { ModelGroupRelationFields } from "./utils/helpers/base.service.helpers";
import { PrismaModels, PrismaClient, ExtractPrismaFilters, ExtractPrismaData, ExtractPrismaQueryOptions } from "../../generated";
import { ServiceBaseContext } from "./types/base.service.types";
type Models = PrismaModels<any>;
type CreateData<TModelName extends keyof Models> = ExtractPrismaData<Models[TModelName]["CreateArgs"]>;
type CreateManyData<TModelName extends keyof Models> = ExtractPrismaData<Models[TModelName]["CreateManyArgs"]>;
type CreateOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["CreateArgs"], "data">;
type CreateManyOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["CreateManyArgs"], "data">;
type CountFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["CountArgs"]>;
type FindManyFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["FindManyArgs"]>;
type FindManyOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["FindManyArgs"], "where">;
type FindOneFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["FindFirstArgs"]>;
type FindOneOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["FindFirstArgs"], "where">;
type UpdateOneFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["UpdateArgs"]>;
type UpdateOneData<TModelName extends keyof Models> = ExtractPrismaData<Models[TModelName]["UpdateArgs"]>;
type UpdateOneOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["UpdateArgs"], "where" | "data">;
type UpdateManyFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["UpdateManyArgs"]>;
type UpdateManyData<TModelName extends keyof Models> = ExtractPrismaData<Models[TModelName]["UpdateManyArgs"]>;
type UpdateManyOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["UpdateManyArgs"], "where" | "data">;
type DeleteOneFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["DeleteArgs"]>;
type DeleteManyFilters<TModelName extends keyof Models> = ExtractPrismaFilters<Models[TModelName]["DeleteManyArgs"]>;
type GetPayload<TModelName extends keyof Models, TOptions extends Record<string, any>> = PrismaModels<TOptions>[TModelName]["GetPayload"];
export interface ServiceOperationHooks {
    beforeOperation?: (params: any) => void | Promise<void>;
    afterOperation?: (result: any, params: any) => void | Promise<void>;
    beforePrisma?: (prismaArgs: any, params: any) => any | Promise<any>;
    afterPrisma?: (result: any, params: any) => any | Promise<any>;
}
/**
 * Base service class for handling CRUD operations on a specific model.
 * This class provides standard implementation of data operations that can be extended
 * by model-specific service classes.
 *
 * @class BaseService
 *
 * @example
 * ```ts
 * import { BaseService } from "arkos/services";
 *
 * export class UserService extends BaseService<"user"> {}
 *
 * const userService = new UserService("user");
 * ```
 *
 * @see {@link https://www.arkosjs.com/docs/reference/base-service}
 * @see {@link https://www.arkosjs.com/docs/guide/accessing-request-context-in-services}
 */
export declare class BaseService<TModelName extends keyof Models = keyof Models> {
    modelName: TModelName;
    relationFields: ModelGroupRelationFields;
    private prismaInstace?;
    constructor(modelName: TModelName);
    get prisma(): PrismaClient;
    private executeOperation;
    private executeTransactionOperation;
    private executeHooks;
    private buildHookParams;
    private buildTransactionHookParams;
    private handlePasswordHashing;
    private processRelationFieldsInBody;
    private buildPrismaArgs;
    private executeTransactionLogic;
    private shouldHashPassword;
    private processPasswordHashing;
    /**
     * Creates a single record in the database.
     *
     * @param data - The data for creating the record
     * @param queryOptions - Optional Prisma query options (select, include, etc.)
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const user = await userService.createOne({
     *   name: "John Doe",
     *   email: "john@example.com"
     * });
     * ```
     */
    createOne<TOptions extends CreateOptions<TModelName>>(data: CreateData<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions>>;
    /**
     * Creates multiple records in the database.
     *
     * @param data - Array of data objects or object with data array
     * @param queryOptions - Optional Prisma query options
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const result = await userService.createMany([
     *   { name: "John Doe", email: "john@example.com" },
     *   { name: "Jane Smith", email: "jane@example.com" }
     * ]);
     * ```
     */
    createMany<TOptions extends CreateManyOptions<TModelName>>(data: CreateManyData<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions>[]>;
    /**
     * Counts records matching the specified filters.
     *
     * @param filters - Optional where conditions
     * @param queryOptions - Optional Prisma query options
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const total = await userService.count({ status: "active" });
     * ```
     */
    count(filters?: CountFilters<TModelName>, context?: ServiceBaseContext): Promise<number>;
    /**
     * Finds multiple records matching the specified filters.
     *
     * @param filters - Optional where conditions
     * @param queryOptions - Optional Prisma query options (select, include, orderBy, skip, take, etc.)
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const users = await userService.findMany(
     *   { status: "active" },
     *   { orderBy: { createdAt: "desc" }, take: 10 }
     * );
     * ```
     */
    findMany<TOptions extends FindManyOptions<TModelName>>(filters?: FindManyFilters<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions>[]>;
    /**
     * Finds a single record by its ID.
     *
     * @param id - The unique identifier of the record
     * @param queryOptions - Optional Prisma query options (select, include, etc.)
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const user = await userService.findById("user-123");
     * ```
     */
    findById<TOptions extends FindOneOptions<TModelName>>(id: string | number, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions> | null>;
    /**
     * Finds the first record matching the specified filters.
     *
     * @param filters - Where conditions to filter records
     * @param queryOptions - Optional Prisma query options
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const user = await userService.findOne({ email: "john@example.com" });
     * ```
     */
    findOne<TOptions extends FindOneOptions<TModelName>>(filters: FindOneFilters<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions> | null>;
    /**
     * Updates a single record matching the specified filters.
     *
     * @param filters - Where conditions to identify the record
     * @param data - The data to update
     * @param queryOptions - Optional Prisma query options
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const updated = await userService.updateOne(
     *   { id: "user-123" },
     *   { name: "John Updated" }
     * );
     * ```
     */
    updateOne<TOptions extends UpdateOneOptions<TModelName>>(filters: UpdateOneFilters<TModelName>, data: UpdateOneData<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions>>;
    /**
     * Updates a single record matching the specified id.
     *
     * @param id - The unique identifier of the record
     * @param data - The data to update
     * @param queryOptions - Optional Prisma query options
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const updated = await userService.updateById("user-123", { name: "John Updated" });
     * ```
     */
    updateById<TOptions extends UpdateOneOptions<TModelName>>(id: string | number, data: UpdateOneData<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions>>;
    /**
     * Updates multiple records matching the specified filters.
     *
     * @param filters - Where conditions to identify records
     * @param data - The data to update
     * @param queryOptions - Optional Prisma query options
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const result = await userService.updateMany(
     *   { status: "pending" },
     *   { status: "active" }
     * );
     * ```
     */
    updateMany<TOptions extends UpdateManyOptions<TModelName>>(filters: UpdateManyFilters<TModelName>, data: UpdateManyData<TModelName>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<{
        count: number;
    }>;
    /**
     * Deletes a single record by its ID.
     *
     * @param id - The unique identifier of the record
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const deleted = await userService.deleteById("user-123");
     * ```
     */
    deleteById(id: string | number, context?: ServiceBaseContext): Promise<GetPayload<TModelName, any>>;
    /**
     * Deletes a single record matching the specified filters.
     *
     * @param filters - Where conditions to identify the record
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const deleted = await userService.deleteOne({ id: "user-123" });
     * ```
     */
    deleteOne(filters: DeleteOneFilters<TModelName>, context?: ServiceBaseContext): Promise<GetPayload<TModelName, any>>;
    /**
     * Deletes multiple records matching the specified filters.
     *
     * @param filters - Where conditions to identify records
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const result = await userService.deleteMany({ status: "inactive" });
     * ```
     */
    deleteMany(filters: DeleteManyFilters<TModelName>, context?: ServiceBaseContext): Promise<{
        count: number;
    }>;
    /**
     * Performs multiple update operations in a single transaction.
     *
     * @param dataArray - Array of update objects each containing filter criteria and data
     * @param queryOptions - Optional Prisma query options applied to all updates
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const results = await userService.batchUpdate([
     *   { id: "user-1", status: "active" },
     *   { id: "user-2", status: "inactive" }
     * ]);
     * ```
     */
    batchUpdate<TOptions extends UpdateOneOptions<TModelName>>(dataArray: UpdateOneData<TModelName>[], queryOptions?: TOptions, context?: ServiceBaseContext): Promise<GetPayload<TModelName, TOptions>[]>;
    /**
     * Performs multiple delete operations in a single transaction.
     *
     * @param batchFilters - Array of where conditions each identifying a record to delete
     * @param context - Optional service execution context
     *
     * @example
     * ```ts
     * const deleted = await userService.batchDelete([
     *   { id: "user-1" },
     *   { id: "user-2" }
     * ]);
     * ```
     */
    batchDelete(batchFilters: Array<DeleteOneFilters<TModelName>>, context?: ServiceBaseContext): Promise<GetPayload<TModelName, any>[]>;
}
export {};