/**
 * WordPress API Client Types
 *
 * TypeScript definitions for the WordPress REST API client
 */
import type { WordPressPost, WordPressPage, WordPressMedia, WordPressUser, WordPressComment, WordPressCategory, WordPressTag, WordPressSiteSettings, WordPressApplicationPassword, PostQueryParams, MediaQueryParams, UserQueryParams, CommentQueryParams, CreatePostRequest, UpdatePostRequest, CreatePageRequest, UpdatePageRequest, CreateUserRequest, UpdateUserRequest, CreateCommentRequest, UpdateCommentRequest, CreateCategoryRequest, UpdateCategoryRequest, CreateTagRequest, UpdateTagRequest, UploadMediaRequest, UpdateMediaRequest, AuthMethod } from "./wordpress.js";
export type { AuthMethod };
export interface AuthConfig {
    method: AuthMethod;
    username?: string;
    password?: string;
    appPassword?: string;
    apiKey?: string;
    secret?: string;
    nonce?: string;
    token?: string;
    clientId?: string;
}
export interface AppPasswordCredentials {
    username: string;
    appPassword: string;
}
export interface JwtCredentials {
    username: string;
    password: string;
    jwtToken?: string;
    jwtSecret?: string;
}
export interface BasicCredentials {
    username: string;
    password: string;
}
export interface ApiKeyCredentials {
    apiKey: string;
}
export type AuthCredentials = AppPasswordCredentials | JwtCredentials | BasicCredentials | ApiKeyCredentials;
export interface AuthStatus {
    isAuthenticated: boolean;
    method: AuthMethod;
    lastAuthAttempt?: Date | null;
    tokenExpiry?: Date | null;
}
export interface WordPressClientConfig {
    baseUrl: string;
    auth: AuthConfig;
    timeout?: number;
    maxRetries?: number;
    userAgent?: string;
    headers?: Record<string, string>;
    rateLimit?: {
        requestsPerMinute: number;
        burstLimit: number;
    };
}
export type HTTPMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
export interface RequestOptions {
    headers?: Record<string, string>;
    timeout?: number;
    retries?: number;
    signal?: AbortSignal;
    params?: Record<string, unknown>;
    idempotent?: boolean;
}
export interface RawResponse<T = unknown> {
    data: T;
    status: number;
    headers: Record<string, string>;
}
export interface APIResponse<T = unknown> {
    data: T;
    status: number;
    statusText: string;
    headers: Record<string, string>;
}
export interface RateLimit {
    limit: number;
    remaining: number;
    reset: number;
    window: number;
}
export interface ClientStats {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    lastRequestTime?: number;
    rateLimitHits: number;
    authFailures: number;
    errors: number;
}
export interface IWordPressClient {
    readonly config: WordPressClientConfig;
    readonly isAuthenticated: boolean;
    readonly stats: ClientStats;
    initialize(): Promise<void>;
    authenticate(): Promise<boolean>;
    disconnect(): Promise<void>;
    request<T = unknown>(method: HTTPMethod, endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    get<T = unknown>(endpoint: string, options?: RequestOptions): Promise<T>;
    post<T = unknown>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    put<T = unknown>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    patch<T = unknown>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    delete<T = unknown>(endpoint: string, options?: RequestOptions): Promise<T>;
    getPosts(params?: PostQueryParams): Promise<WordPressPost[]>;
    getPost(id: number, context?: "view" | "embed" | "edit"): Promise<WordPressPost>;
    createPost(data: CreatePostRequest): Promise<WordPressPost>;
    updatePost(data: UpdatePostRequest): Promise<WordPressPost>;
    deletePost(id: number, force?: boolean): Promise<{
        deleted: boolean;
        previous?: WordPressPost;
    }>;
    getPostRevisions(id: number): Promise<WordPressPost[]>;
    getPages(params?: PostQueryParams): Promise<WordPressPage[]>;
    getPage(id: number, context?: "view" | "embed" | "edit"): Promise<WordPressPage>;
    createPage(data: CreatePageRequest): Promise<WordPressPage>;
    updatePage(data: UpdatePageRequest): Promise<WordPressPage>;
    deletePage(id: number, force?: boolean): Promise<{
        deleted: boolean;
        previous?: WordPressPage;
    }>;
    getPageRevisions(id: number): Promise<WordPressPage[]>;
    getMedia(params?: MediaQueryParams): Promise<WordPressMedia[]>;
    getMediaItem(id: number, context?: "view" | "embed" | "edit"): Promise<WordPressMedia>;
    uploadMedia(data: UploadMediaRequest): Promise<WordPressMedia>;
    uploadFile(fileData: Buffer, filename: string, mimeType: string, meta?: Partial<UploadMediaRequest>, options?: RequestOptions): Promise<WordPressMedia>;
    updateMedia(data: UpdateMediaRequest): Promise<WordPressMedia>;
    deleteMedia(id: number, force?: boolean): Promise<{
        deleted: boolean;
        previous?: WordPressMedia;
    }>;
    getUsers(params?: UserQueryParams): Promise<WordPressUser[]>;
    getUser(id: number | "me", context?: "view" | "embed" | "edit"): Promise<WordPressUser>;
    createUser(data: CreateUserRequest): Promise<WordPressUser>;
    updateUser(data: UpdateUserRequest): Promise<WordPressUser>;
    deleteUser(id: number, reassign?: number): Promise<{
        deleted: boolean;
        previous?: WordPressUser;
    }>;
    getCurrentUser(): Promise<WordPressUser>;
    getComments(params?: CommentQueryParams): Promise<WordPressComment[]>;
    getComment(id: number, context?: "view" | "embed" | "edit"): Promise<WordPressComment>;
    createComment(data: CreateCommentRequest): Promise<WordPressComment>;
    updateComment(data: UpdateCommentRequest): Promise<WordPressComment>;
    deleteComment(id: number, force?: boolean): Promise<{
        deleted: boolean;
        previous?: WordPressComment;
    }>;
    approveComment(id: number): Promise<WordPressComment>;
    rejectComment(id: number): Promise<WordPressComment>;
    spamComment(id: number): Promise<WordPressComment>;
    getCategories(params?: {
        search?: string;
        exclude?: number[];
        include?: number[];
        order?: "asc" | "desc";
        orderby?: string;
        hide_empty?: boolean;
        parent?: number;
        post?: number;
        slug?: string;
    }): Promise<WordPressCategory[]>;
    getCategory(id: number): Promise<WordPressCategory>;
    createCategory(data: CreateCategoryRequest): Promise<WordPressCategory>;
    updateCategory(data: UpdateCategoryRequest): Promise<WordPressCategory>;
    deleteCategory(id: number, force?: boolean): Promise<{
        deleted: boolean;
        previous?: WordPressCategory;
    }>;
    getTags(params?: {
        search?: string;
        exclude?: number[];
        include?: number[];
        order?: "asc" | "desc";
        orderby?: string;
        hide_empty?: boolean;
        post?: number;
        slug?: string;
    }): Promise<WordPressTag[]>;
    getTag(id: number): Promise<WordPressTag>;
    createTag(data: CreateTagRequest): Promise<WordPressTag>;
    updateTag(data: UpdateTagRequest): Promise<WordPressTag>;
    deleteTag(id: number, force?: boolean): Promise<{
        deleted: boolean;
        previous?: WordPressTag;
    }>;
    getSiteSettings(): Promise<WordPressSiteSettings>;
    updateSiteSettings(settings: Partial<WordPressSiteSettings>): Promise<WordPressSiteSettings>;
    getSiteInfo(): Promise<import("./wordpress.js").WordPressSiteInfo>;
    getApplicationPasswords(userId?: number | "me"): Promise<WordPressApplicationPassword[]>;
    createApplicationPassword(userId: number | "me", name: string, appId?: string): Promise<WordPressApplicationPassword>;
    deleteApplicationPassword(userId: number | "me", uuid: string): Promise<{
        deleted: boolean;
    }>;
    search(query: string, types?: string[], subtype?: string): Promise<import("./wordpress.js").WordPressSearchResult[]>;
    ping(): Promise<boolean>;
    getServerInfo(): Promise<Record<string, unknown>>;
    validateEndpoint(endpoint: string): boolean;
    buildUrl(endpoint: string, params?: Record<string, unknown>): string;
}
export interface IAuthProvider {
    readonly method: AuthMethod;
    authenticate(client: IWordPressClient): Promise<boolean>;
    addAuthHeaders(headers: Record<string, string>): void;
    refreshAuth?(): Promise<boolean>;
    validateAuth?(): Promise<boolean>;
}
export declare class WordPressAPIError extends Error {
    readonly statusCode?: number;
    readonly code?: string;
    data?: unknown;
    constructor(message: string, statusCode?: number, code?: string, data?: unknown);
}
export declare class AuthenticationError extends WordPressAPIError {
    constructor(message: string, method: AuthMethod);
}
export declare class RateLimitError extends WordPressAPIError {
    constructor(message: string, resetTime: number);
}
export declare class ValidationError extends WordPressAPIError {
    constructor(message: string, field?: string);
}
export declare function isWordPressAPIError(error: unknown): error is WordPressAPIError;
export declare function isAuthenticationError(error: unknown): error is AuthenticationError;
export declare function isRateLimitError(error: unknown): error is RateLimitError;
export declare function isValidationError(error: unknown): error is ValidationError;
export declare function isWordPressPost(obj: unknown): obj is WordPressPost;
export declare function isWordPressPage(obj: unknown): obj is WordPressPage;
export declare function isWordPressMedia(obj: unknown): obj is WordPressMedia;
export declare function isWordPressUser(obj: unknown): obj is WordPressUser;
export declare function isWordPressComment(obj: unknown): obj is WordPressComment;
//# sourceMappingURL=client.d.ts.map