import { n as ServiceHandle, t as ServiceClientOptions } from "../service-rpc-BugpSF7V.mjs";

//#region src/http/http-types.d.ts
/** HTTP method (`hal::network::HttpClientIface::Method`). */
type HttpMethod = 'Get' | 'Post' | 'Put' | 'Patch' | 'Delete' | 'Head';
/** TLS verification mode (`hal::network::HttpClientIface::TlsVerifyMode`). */
type HttpTlsVerifyMode = 'Default' | 'Verify' | 'Skip';
/** Platform error code (`hal::network::HttpClientIface::ErrorCode`). */
type HttpErrorCode = 'Ok' | 'InvalidArgument' | 'NotStarted' | 'UnsupportedTransport' | 'BodyTooLarge' | 'FileTooLarge' | 'FileOpenFailed' | 'ClientInitFailed' | 'RequestFailed' | 'Canceled' | 'Timeout';
/** HTTP request payload (`helper::Http::HttpRequest`). */
type HttpRequest = {
  url: string;
  method?: HttpMethod;
  headers?: Record<string, string>;
  body?: string;
  timeout_ms?: number;
  tls_verify?: HttpTlsVerifyMode;
  cert_pem?: string;
  use_crt_bundle?: boolean;
  download_path?: string;
  max_response_size?: number;
  max_file_size?: number;
  retry_count?: number;
  retry_on_status_codes?: number[];
};
/** HTTP response payload (`helper::Http::HttpResponse`). */
type HttpResponse = {
  request_id?: number;
  status_code?: number;
  headers?: Record<string, string>;
  body?: string;
  file_path?: string;
  error?: HttpErrorCode;
  error_message?: string;
};
/** Request lifecycle state (`helper::Http::RequestState`). */
type HttpRequestState = 'Queued' | 'Running' | 'Completed' | 'Failed' | 'Canceled';
/** Request state snapshot (`helper::Http::RequestStateInfo`). */
type HttpRequestStateInfo = {
  request_id: number;
  state: HttpRequestState;
  error?: HttpErrorCode;
  status_code?: number;
  downloaded?: number;
  total?: number;
};
/** Service statistics (`helper::Http::Statistics`). */
type HttpStatistics = {
  submitted_count: number;
  completed_count: number;
  failed_count: number;
  canceled_count: number;
};
//#endregion
//#region src/http/http-client.d.ts
/** Registered name (`helper::Http::get_name()`). */
declare const HTTP_SERVICE_NAME = "Http";
/** RPC function names (`helper::Http::FunctionId`). */
declare const HTTP_FUNCTIONS: {
  readonly Request: "Request";
  readonly RequestAsync: "RequestAsync";
  readonly CancelRequest: "CancelRequest";
  readonly GetRequestState: "GetRequestState";
  readonly ResetStatistics: "ResetStatistics";
};
type HttpClientOptions = ServiceClientOptions;
declare function isHttpAvailable(options?: HttpClientOptions): boolean;
declare function openHttp(options?: HttpClientOptions): ServiceHandle;
declare function closeHttp(handle: ServiceHandle, options?: HttpClientOptions): void;
declare function request(handle: ServiceHandle, req: HttpRequest, options?: HttpClientOptions): HttpResponse;
declare function requestAsync(handle: ServiceHandle, req: HttpRequest, options?: HttpClientOptions): number;
declare function cancelRequest(handle: ServiceHandle, requestId: number, options?: HttpClientOptions): void;
declare function getRequestState(handle: ServiceHandle, requestId: number, options?: HttpClientOptions): HttpRequestStateInfo;
declare function resetHttpStatistics(handle: ServiceHandle, options?: HttpClientOptions): void;
//#endregion
//#region src/http/http.d.ts
type HttpModuleOptions = HttpClientOptions;
/**
 * Inject a mock RPC host and reset the cached service handle (vitest / Node only).
 *
 * @param options - Client options, typically `{ host }` from `@brookesia/service/hosts/http`
 */
declare function configure(options: HttpModuleOptions): void;
declare const http: {
  /** @returns `true` when the HTTP service is registered */available(): boolean; /** Release the HTTP service binding. */
  close(): void;
  /**
   * Perform a blocking HTTP request (maps to C++ `Request`).
   *
   * @param req - `{ url, method, headers?, body?, timeout_ms? }`
   * @returns Response with `status_code`, `body`, headers
   *
   * @example
   * const res = http.request({ url: 'https://example.com', method: 'Get' });
   */
  request(req: HttpRequest): HttpResponse;
  /**
   * Start an asynchronous HTTP request (maps to C++ `RequestAsync`).
   *
   * @param req - Request parameters (same as {@link request})
   * @returns Request ID for polling via {@link getRequestState}
   */
  requestAsync(req: HttpRequest): number;
  /**
   * Cancel an in-flight async request.
   *
   * @param requestId - ID from {@link requestAsync}
   */
  cancelRequest(requestId: number): void;
  /**
   * Poll async request progress / result.
   *
   * @param requestId - ID from {@link requestAsync}
   * @returns `{ state, status_code, body, ... }` — `state` is `'Completed'` when done
   */
  getRequestState(requestId: number): HttpRequestStateInfo; /** Reset HTTP client statistics counters. */
  resetStatistics(): void;
};
//#endregion
export { HTTP_FUNCTIONS, HTTP_SERVICE_NAME, type HttpClientOptions, type HttpErrorCode, type ServiceHandle as HttpHandle, type HttpMethod, type HttpModuleOptions, type HttpRequest, type HttpRequestState, type HttpRequestStateInfo, type HttpResponse, type HttpStatistics, type HttpTlsVerifyMode, cancelRequest, closeHttp, configure, http as default, getRequestState, isHttpAvailable, openHttp, request, requestAsync, resetHttpStatistics };
//# sourceMappingURL=index.d.mts.map