import { Adapter, AdapterFlags, Condition, Context, ContextualArgs, FlagsOf, MaybeContextualArg, Paginator, PreparedModel, PreparedStatement, Repository, Sequence, SequenceOptions, Statement } from "@decaf-ts/core";
import { BaseError, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
import { HttpConfig, HttpFlags } from "./types";
import { Model } from "@decaf-ts/decorator-validation";
import { Constructor } from "@decaf-ts/decoration";
export declare function suffixMethod(obj: any, before: (...args: any[]) => any, suffix: (...args: any[]) => any, beforeName?: string): void;
/**
 * @description Abstract HTTP adapter for REST API interactions
 * @summary Provides a base implementation for HTTP adapters with methods for CRUD operations,
 * URL construction, and error handling. This class extends the core Adapter class and
 * implements the necessary methods for HTTP communication. Concrete implementations
 * must provide specific HTTP client functionality.
 * @template Y - The native HTTP client type
 * @template Q - The query type used by the adapter
 * @template F - The HTTP flags type, extending HttpFlags
 * @template C - The context type, extending Context<F>
 * @param {Y} native - The native HTTP client instance
 * @param {HttpConfig} config - Configuration for the HTTP adapter
 * @param {string} flavour - The adapter flavor identifier
 * @param {string} [alias] - Optional alias for the adapter
 * @class HttpAdapter
 * @example
 * ```typescript
 * // Example implementation with Axios
 * class AxiosAdapter extends HttpAdapter<AxiosInstance, AxiosRequestConfig> {
 *   constructor(config: HttpConfig) {
 *     super(axios.create(), config, 'axios');
 *   }
 *
 *   async request<V>(details: AxiosRequestConfig): Promise<V> {
 *     const response = await this.native.request(details);
 *     return response.data;
 *   }
 *
 *   // Implement other abstract methods...
 * }
 * ```
 */
export declare abstract class HttpAdapter<CONF extends HttpConfig, CON, REQ, Q extends PreparedStatement<any> = PreparedStatement<any>, C extends Context<HttpFlags> = Context<HttpFlags>> extends Adapter<CONF, CON, Q, C> {
    protected constructor(config: CONF, flavour: string, alias?: string);
    /**
     * @description Generates operation flags with HTTP headers
     * @summary Extends the base flags method to ensure HTTP headers exist on the flags payload.
     * @template M - The model type
     * @param {OperationKeys|string} operation - The type of operation being performed
     * @param {Constructor | Constructor[]} model - The target model constructor(s)
     * @param {Partial<FlagsOf<C>>} overrides - Optional flag overrides
     * @param {...any[]} args - Additional arguments forwarded to the base implementation
     * @return {Promise<FlagsOf<C>>} The flags object with headers
     */
    protected flags<M extends Model>(operation: OperationKeys | string, model: Constructor<M> | Constructor<M>[], overrides: Partial<FlagsOf<C>>): Promise<FlagsOf<C>>;
    protected Dispatch(): any;
    protected getEventHeaders(): Promise<{}>;
    /**
     * @description Returns the repository constructor for this adapter
     * @summary Provides the RestService class as the repository implementation for this HTTP adapter.
     * This method is used to create repository instances that work with this adapter type.
     * @template R - Repository subtype working with this adapter
     * @return {Constructor<R>} The repository constructor
     */
    repository<R extends Repository<any, Adapter<CONF, CON, Q, C>>>(): Constructor<R>;
    /**
     * @description Prepares a model for persistence
     * @summary Converts a model instance into a format suitable for database storage,
     * handling column mapping and separating transient properties
     * @template M - The model type
     * @param {M} model - The model instance to prepare
     * @param pk - The primary key property name
     * @param args
     * @return The prepared data
     */
    prepare<M extends Model>(model: M, ...args: ContextualArgs<C>): PreparedModel;
    /**
     * @description Converts database data back into a model instance
     * @summary Reconstructs a model instance from database data, handling column mapping
     * and reattaching transient properties
     * @template M - The model type
     * @param obj - The database record
     * @param {string|Constructor<M>} clazz - The model class or name
     * @param pk - The primary key property name
     * @param {string|number|bigint} id - The primary key value
     * @return {M} The reconstructed model instance
     */
    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): M;
    protected toTableName<M extends Model>(t: string | Constructor<M>): string;
    protected toHeaders(ctx: C): {
        [x: string]: any;
    };
    /**
     * @description Constructs a URL for API requests
     * @summary Builds a complete URL for API requests using the configured protocol and host,
     * the specified table name, and optional query parameters. The method handles URL encoding.
     * @param {string | Constructor} tableName - The name of the table or endpoint
     * @return {string} The encoded URL string
     */
    url<M extends Model>(tableName: string | Constructor<M>): string;
    /**
     * @description Constructs a URL for API requests
     * @summary Builds a complete URL for API requests using the configured protocol and host,
     * the specified table name, and optional query parameters. The method handles URL encoding.
     * @param {string | Constructor} tableName - The name of the table or endpoint
     * @param {string[]} pathParams - Optional query parameters
     * @return {string} The encoded URL string
     */
    url<M extends Model>(tableName: string | Constructor<M>, pathParams: string[]): string;
    /**
     * @description Constructs a URL for API requests
     * @summary Builds a complete URL for API requests using the configured protocol and host,
     * the specified table name, and optional query parameters. The method handles URL encoding.
     * @param {string | Constructor} tableName - The name of the table or endpoint
     * @param {Record<string, string | number>} queryParams - Optional query parameters
     * @return {string} The encoded URL string
     */
    url<M extends Model>(tableName: string | Constructor<M>, queryParams: Record<string, string | number>): string;
    url<M extends Model>(tableName: string | Constructor<M>, pathParams: string[], queryParams: Record<string, string | number>): string;
    abstract toRequest(query: Q): REQ;
    abstract toRequest(ctx: C): REQ;
    abstract toRequest(query: Q, ctx: C): REQ;
    abstract toRequest(ctxOrQuery: C | Q, ctx?: C): REQ;
    /**
     * @description Sends an HTTP request
     * @summary Abstract method that must be implemented by subclasses to send HTTP requests
     * using the native HTTP client. This is the core method for making API calls.
     * @template V - The response value type
     * @param {REQ} details - The request details specific to the HTTP client
     * @return {Promise<V>} A promise that resolves with the response data
     */
    abstract request<V>(details: REQ, ...args: MaybeContextualArg<C>): Promise<V>;
    protected extractIdArgs<M extends Model>(model: Constructor<M> | string, id: PrimaryKeyType): string[];
    parseResponse<M extends Model>(clazz: Constructor<M> | undefined, method: OperationKeys | string, res: any): any;
    /**
     * @description Creates a new resource
     * @summary Abstract method that must be implemented by subclasses to create a new resource
     * via HTTP. This typically corresponds to a POST request.
     * @param {string} tableName - The name of the table or endpoint
     * @param {string|number} id - The identifier for the resource
     * @param {Record<string, any>} model - The data model to create
     * @param {...any[]} args - Additional arguments
     * @return {Promise<Record<string, any>>} A promise that resolves with the created resource
     */
    abstract create<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
    /**
     * @description Retrieves a resource by ID
     * @summary Abstract method that must be implemented by subclasses to retrieve a resource
     * via HTTP. This typically corresponds to a GET request.
     * @param {string} tableName - The name of the table or endpoint
     * @param {string|number|bigint} id - The identifier for the resource
     * @param {...any[]} args - Additional arguments
     * @return {Promise<Record<string, any>>} A promise that resolves with the retrieved resource
     */
    abstract read<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
    /**
     * @description Updates an existing resource
     * @summary Abstract method that must be implemented by subclasses to update a resource
     * via HTTP. This typically corresponds to a PUT or PATCH request.
     * @param {string} tableName - The name of the table or endpoint
     * @param {string|number} id - The identifier for the resource
     * @param {Record<string, any>} model - The updated data model
     * @param {...any[]} args - Additional arguments
     * @return {Promise<Record<string, any>>} A promise that resolves with the updated resource
     */
    abstract update<M extends Model>(tableName: Constructor<M>, id: string | number, model: Record<string, any>, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
    /**
     * @description Deletes a resource by ID
     * @summary Abstract method that must be implemented by subclasses to delete a resource
     * via HTTP. This typically corresponds to a DELETE request.
     * @param {string} tableName - The name of the table or endpoint
     * @param {string|number|bigint} id - The identifier for the resource to delete
     * @param {...any[]} args - Additional arguments
     * @return {Promise<Record<string, any>>} A promise that resolves with the deletion result
     */
    abstract delete<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
    /**
     * @description Executes a raw query
     * @summary Method for executing raw queries directly with the HTTP client.
     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
     * Subclasses can override this method to provide implementation.
     * @template R - The result type
     * @param {Q} rawInput - The raw query input
     * @param {boolean} process - Whether to process the result
     * @param {...any[]} args - Additional arguments
     * @return {Promise<R>} A promise that resolves with the query result
     * @throws {UnsupportedError} Always throws as this method is not supported by default
     */
    raw<R>(rawInput: Q, ...args: ContextualArgs<C>): Promise<R>;
    /**
     * @description Creates a sequence
     * @summary Method for creating a sequence for generating unique identifiers.
     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
     * Subclasses can override this method to provide implementation.
     * @param {SequenceOptions} options - Options for creating the sequence
     * @return {Promise<Sequence>} A promise that resolves with the created sequence
     * @throws {UnsupportedError} Always throws as this method is not supported by default
     */
    Sequence(options: SequenceOptions): Promise<Sequence>;
    /**
     * @description Creates a statement for querying
     * @summary Method for creating a statement for building and executing queries.
     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
     * Subclasses can override this method to provide implementation.
     * @template M - The model type
     * @template ! - The raw query type
     * @return {Statement<Q, M, any>} A statement object for building queries
     * @throws {UnsupportedError} Always throws as this method is not supported by default
     */
    Statement<M extends Model>(overrides?: Partial<AdapterFlags>): Statement<M, Adapter<CONF, CON, Q, C>, any>;
    Paginator<M extends Model>(query: Q, size: number, clazz: Constructor<M>): Paginator<M, M, Q>;
    /**
     * @description Parses a condition into a query
     * @summary Method for parsing a condition object into a query format understood by the HTTP client.
     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
     * Subclasses can override this method to provide implementation.
     * @param {Condition<any>} condition - The condition to parse
     * @return {Q} The parsed query
     * @throws {UnsupportedError} Always throws as this method is not supported by default
     */
    parseCondition(condition: Condition<any>): Q;
    static parseError<E extends BaseError>(err: Error | string, ...args: any[]): E;
    static decoration(): void;
}