imposters 0.1.0

package/dist/dts/client/ImpostersClient.d.ts

@@ -0,0 +1,1868 @@
+import type { HttpClient } from "@effect/platform";
+import type { Effect } from "effect";
+import { Context, Layer } from "effect";
+export declare const makeImpostersClient: (baseUrl?: string) => Effect.Effect<{
+    readonly imposters: {
+        readonly createImposter: <WithResponse extends boolean = false>(request: {
+            readonly payload: {
+                readonly name?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly port?: (number & import("effect/Brand").Brand<"PortNumber">) | undefined;
+                readonly protocol: "HTTP";
+                readonly adminPath: string;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiConflictError | import("../api/ApiErrors").ApiServiceError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly listImposters: <WithResponse extends boolean = false>(request: {
+            readonly urlParams: {
+                readonly limit: number;
+                readonly offset: number;
+                readonly status?: "running" | "stopped" | "starting" | "stopping" | undefined;
+                readonly protocol?: "HTTP" | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly pagination: {
+                readonly limit: number & import("effect/Brand").Brand<"PositiveInteger">;
+                readonly offset: number;
+                readonly total: number;
+                readonly hasMore: boolean;
+            };
+            readonly imposters: readonly {
+                readonly status: "running" | "stopped" | "starting" | "stopping";
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly protocol: "HTTP";
+                readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | undefined;
+                readonly createdAt: import("effect/DateTime").Utc;
+                readonly endpointCount: number;
+                readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly uptime?: string | undefined;
+                readonly endpoints?: readonly {
+                    readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly status: number;
+                    readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly hasDelay: boolean;
+                    readonly delayMs?: number | undefined;
+                }[] | undefined;
+                readonly statistics?: {
+                    readonly totalRequests: number;
+                    readonly requestsPerMinute: number;
+                    readonly averageResponseTime: number;
+                    readonly errorRate: number;
+                    readonly requestsByMethod: {
+                        readonly [x: string]: number;
+                    };
+                    readonly requestsByStatusCode: {
+                        readonly [x: string]: number;
+                    };
+                    readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                    readonly p50ResponseTime?: number | undefined;
+                    readonly p95ResponseTime?: number | undefined;
+                    readonly p99ResponseTime?: number | undefined;
+                } | undefined;
+            }[];
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly pagination: {
+                readonly limit: number & import("effect/Brand").Brand<"PositiveInteger">;
+                readonly offset: number;
+                readonly total: number;
+                readonly hasMore: boolean;
+            };
+            readonly imposters: readonly {
+                readonly status: "running" | "stopped" | "starting" | "stopping";
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly protocol: "HTTP";
+                readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | undefined;
+                readonly createdAt: import("effect/DateTime").Utc;
+                readonly endpointCount: number;
+                readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly uptime?: string | undefined;
+                readonly endpoints?: readonly {
+                    readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly status: number;
+                    readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly hasDelay: boolean;
+                    readonly delayMs?: number | undefined;
+                }[] | undefined;
+                readonly statistics?: {
+                    readonly totalRequests: number;
+                    readonly requestsPerMinute: number;
+                    readonly averageResponseTime: number;
+                    readonly errorRate: number;
+                    readonly requestsByMethod: {
+                        readonly [x: string]: number;
+                    };
+                    readonly requestsByStatusCode: {
+                        readonly [x: string]: number;
+                    };
+                    readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                    readonly p50ResponseTime?: number | undefined;
+                    readonly p95ResponseTime?: number | undefined;
+                    readonly p99ResponseTime?: number | undefined;
+                } | undefined;
+            }[];
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly getImposter: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly updateImposter: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly payload: {
+                readonly status?: "running" | "stopped" | "starting" | "stopping" | undefined;
+                readonly name?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly port?: (number & import("effect/Brand").Brand<"PortNumber">) | undefined;
+                readonly adminPath?: string | undefined;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | null | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("../api/ApiErrors").ApiConflictError | import("../api/ApiErrors").ApiServiceError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly deleteImposter: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly urlParams: {
+                readonly force: boolean;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly message: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly deletedAt: import("effect/DateTime").Utc;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly message: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly deletedAt: import("effect/DateTime").Utc;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("../api/ApiErrors").ApiConflictError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly addStub: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+            };
+            readonly payload: {
+                readonly predicates: readonly {
+                    readonly field: "method" | "headers" | "body" | "path" | "query";
+                    readonly value: unknown;
+                    readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                    readonly caseSensitive: boolean;
+                }[];
+                readonly responses: readonly [{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }, ...{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }[]];
+                readonly responseMode: "sequential" | "random" | "repeat";
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly listStubs: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }[], import("@effect/platform/HttpClientResponse").HttpClientResponse] : readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }[], import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly updateStub: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+                readonly stubId: string;
+            };
+            readonly payload: {
+                readonly predicates?: readonly {
+                    readonly field: "method" | "headers" | "body" | "path" | "query";
+                    readonly value: unknown;
+                    readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                    readonly caseSensitive: boolean;
+                }[] | undefined;
+                readonly responses?: readonly [{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }, ...{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }[]] | undefined;
+                readonly responseMode?: "sequential" | "random" | "repeat" | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly deleteStub: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+                readonly stubId: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly listRequests: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly urlParams: {
+                readonly method?: string | undefined;
+                readonly limit: number;
+                readonly path?: string | undefined;
+                readonly status?: number | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly response: {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: string | undefined;
+                readonly status: number;
+                readonly matchedStubId?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly proxied: boolean;
+            };
+            readonly timestamp: import("effect/DateTime").Utc;
+            readonly imposterId: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly request: {
+                readonly method: string;
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: unknown;
+                readonly path: string;
+                readonly query: {
+                    readonly [x: string]: string;
+                };
+            };
+            readonly duration: number;
+        }[], import("@effect/platform/HttpClientResponse").HttpClientResponse] : readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly response: {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: string | undefined;
+                readonly status: number;
+                readonly matchedStubId?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly proxied: boolean;
+            };
+            readonly timestamp: import("effect/DateTime").Utc;
+            readonly imposterId: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly request: {
+                readonly method: string;
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: unknown;
+                readonly path: string;
+                readonly query: {
+                    readonly [x: string]: string;
+                };
+            };
+            readonly duration: number;
+        }[], import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly clearRequests: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly message: string;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly message: string;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly getImposterStats: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly totalRequests: number;
+            readonly requestsPerMinute: number;
+            readonly averageResponseTime: number;
+            readonly errorRate: number;
+            readonly requestsByMethod: {
+                readonly [x: string]: number;
+            };
+            readonly requestsByStatusCode: {
+                readonly [x: string]: number;
+            };
+            readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+            readonly p50ResponseTime?: number | undefined;
+            readonly p95ResponseTime?: number | undefined;
+            readonly p99ResponseTime?: number | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly totalRequests: number;
+            readonly requestsPerMinute: number;
+            readonly averageResponseTime: number;
+            readonly errorRate: number;
+            readonly requestsByMethod: {
+                readonly [x: string]: number;
+            };
+            readonly requestsByStatusCode: {
+                readonly [x: string]: number;
+            };
+            readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+            readonly p50ResponseTime?: number | undefined;
+            readonly p95ResponseTime?: number | undefined;
+            readonly p99ResponseTime?: number | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly resetImposterStats: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly message: string;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly message: string;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+    };
+    readonly healthCheck: <WithResponse extends boolean = false>(request: void | {
+        readonly withResponse?: WithResponse;
+    }) => Effect.Effect<WithResponse extends true ? [{
+        readonly status: "healthy" | "unhealthy";
+        readonly uptime: string;
+        readonly timestamp: import("effect/DateTime").Utc;
+        readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+        readonly system: {
+            readonly imposters: {
+                readonly running: number;
+                readonly stopped: number;
+                readonly total: number;
+            };
+            readonly memory: {
+                readonly used: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly free: string & import("effect/Brand").Brand<"NonEmptyString">;
+            };
+            readonly ports: {
+                readonly available: number;
+                readonly allocated: number;
+            };
+        };
+    }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+        readonly status: "healthy" | "unhealthy";
+        readonly uptime: string;
+        readonly timestamp: import("effect/DateTime").Utc;
+        readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+        readonly system: {
+            readonly imposters: {
+                readonly running: number;
+                readonly stopped: number;
+                readonly total: number;
+            };
+            readonly memory: {
+                readonly used: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly free: string & import("effect/Brand").Brand<"NonEmptyString">;
+            };
+            readonly ports: {
+                readonly available: number;
+                readonly allocated: number;
+            };
+        };
+    }, import("@effect/platform/HttpClientError").HttpClientError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+    readonly serverInfo: <WithResponse extends boolean = false>(request: void | {
+        readonly withResponse?: WithResponse;
+    }) => Effect.Effect<WithResponse extends true ? [{
+        readonly server: {
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly buildTime: import("effect/DateTime").Utc;
+            readonly platform: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly protocols: readonly "HTTP"[];
+        };
+        readonly configuration: {
+            readonly maxImposters: number;
+            readonly portRange: {
+                readonly min: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly max: number & import("effect/Brand").Brand<"PortNumber">;
+            };
+            readonly defaultTimeout: number;
+            readonly logLevel: "error" | "debug" | "info" | "warn";
+        };
+        readonly features: {
+            readonly openApiGeneration: boolean;
+            readonly clientGeneration: boolean;
+            readonly authentication: boolean;
+            readonly clustering: boolean;
+        };
+    }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+        readonly server: {
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly buildTime: import("effect/DateTime").Utc;
+            readonly platform: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly protocols: readonly "HTTP"[];
+        };
+        readonly configuration: {
+            readonly maxImposters: number;
+            readonly portRange: {
+                readonly min: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly max: number & import("effect/Brand").Brand<"PortNumber">;
+            };
+            readonly defaultTimeout: number;
+            readonly logLevel: "error" | "debug" | "info" | "warn";
+        };
+        readonly features: {
+            readonly openApiGeneration: boolean;
+            readonly clientGeneration: boolean;
+            readonly authentication: boolean;
+            readonly clustering: boolean;
+        };
+    }, import("@effect/platform/HttpClientError").HttpClientError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+}, never, HttpClient.HttpClient>;
+export type ImpostersClientShape = Effect.Effect.Success<ReturnType<typeof makeImpostersClient>>;
+declare const ImpostersClient_base: Context.TagClass<ImpostersClient, "ImpostersClient", {
+    readonly imposters: {
+        readonly createImposter: <WithResponse extends boolean = false>(request: {
+            readonly payload: {
+                readonly name?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly port?: (number & import("effect/Brand").Brand<"PortNumber">) | undefined;
+                readonly protocol: "HTTP";
+                readonly adminPath: string;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiConflictError | import("../api/ApiErrors").ApiServiceError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly listImposters: <WithResponse extends boolean = false>(request: {
+            readonly urlParams: {
+                readonly limit: number;
+                readonly offset: number;
+                readonly status?: "running" | "stopped" | "starting" | "stopping" | undefined;
+                readonly protocol?: "HTTP" | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly pagination: {
+                readonly limit: number & import("effect/Brand").Brand<"PositiveInteger">;
+                readonly offset: number;
+                readonly total: number;
+                readonly hasMore: boolean;
+            };
+            readonly imposters: readonly {
+                readonly status: "running" | "stopped" | "starting" | "stopping";
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly protocol: "HTTP";
+                readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | undefined;
+                readonly createdAt: import("effect/DateTime").Utc;
+                readonly endpointCount: number;
+                readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly uptime?: string | undefined;
+                readonly endpoints?: readonly {
+                    readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly status: number;
+                    readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly hasDelay: boolean;
+                    readonly delayMs?: number | undefined;
+                }[] | undefined;
+                readonly statistics?: {
+                    readonly totalRequests: number;
+                    readonly requestsPerMinute: number;
+                    readonly averageResponseTime: number;
+                    readonly errorRate: number;
+                    readonly requestsByMethod: {
+                        readonly [x: string]: number;
+                    };
+                    readonly requestsByStatusCode: {
+                        readonly [x: string]: number;
+                    };
+                    readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                    readonly p50ResponseTime?: number | undefined;
+                    readonly p95ResponseTime?: number | undefined;
+                    readonly p99ResponseTime?: number | undefined;
+                } | undefined;
+            }[];
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly pagination: {
+                readonly limit: number & import("effect/Brand").Brand<"PositiveInteger">;
+                readonly offset: number;
+                readonly total: number;
+                readonly hasMore: boolean;
+            };
+            readonly imposters: readonly {
+                readonly status: "running" | "stopped" | "starting" | "stopping";
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly protocol: "HTTP";
+                readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | undefined;
+                readonly createdAt: import("effect/DateTime").Utc;
+                readonly endpointCount: number;
+                readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly uptime?: string | undefined;
+                readonly endpoints?: readonly {
+                    readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly status: number;
+                    readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                    readonly hasDelay: boolean;
+                    readonly delayMs?: number | undefined;
+                }[] | undefined;
+                readonly statistics?: {
+                    readonly totalRequests: number;
+                    readonly requestsPerMinute: number;
+                    readonly averageResponseTime: number;
+                    readonly errorRate: number;
+                    readonly requestsByMethod: {
+                        readonly [x: string]: number;
+                    };
+                    readonly requestsByStatusCode: {
+                        readonly [x: string]: number;
+                    };
+                    readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                    readonly p50ResponseTime?: number | undefined;
+                    readonly p95ResponseTime?: number | undefined;
+                    readonly p99ResponseTime?: number | undefined;
+                } | undefined;
+            }[];
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly getImposter: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly updateImposter: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly payload: {
+                readonly status?: "running" | "stopped" | "starting" | "stopping" | undefined;
+                readonly name?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly port?: (number & import("effect/Brand").Brand<"PortNumber">) | undefined;
+                readonly adminPath?: string | undefined;
+                readonly proxy?: {
+                    readonly targetUrl: string;
+                    readonly mode: "passthrough" | "record";
+                    readonly addHeaders?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly removeHeaders: readonly string[];
+                    readonly followRedirects: boolean;
+                    readonly timeout: number;
+                } | null | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly status: "running" | "stopped" | "starting" | "stopping";
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly port: number & import("effect/Brand").Brand<"PortNumber">;
+            readonly protocol: "HTTP";
+            readonly adminPath: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly proxy?: {
+                readonly targetUrl: string;
+                readonly mode: "passthrough" | "record";
+                readonly addHeaders?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly removeHeaders: readonly string[];
+                readonly followRedirects: boolean;
+                readonly timeout: number;
+            } | undefined;
+            readonly createdAt: import("effect/DateTime").Utc;
+            readonly endpointCount: number;
+            readonly adminUrl: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly uptime?: string | undefined;
+            readonly endpoints?: readonly {
+                readonly method: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly path: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly status: number;
+                readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly hasDelay: boolean;
+                readonly delayMs?: number | undefined;
+            }[] | undefined;
+            readonly statistics?: {
+                readonly totalRequests: number;
+                readonly requestsPerMinute: number;
+                readonly averageResponseTime: number;
+                readonly errorRate: number;
+                readonly requestsByMethod: {
+                    readonly [x: string]: number;
+                };
+                readonly requestsByStatusCode: {
+                    readonly [x: string]: number;
+                };
+                readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+                readonly p50ResponseTime?: number | undefined;
+                readonly p95ResponseTime?: number | undefined;
+                readonly p99ResponseTime?: number | undefined;
+            } | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("../api/ApiErrors").ApiConflictError | import("../api/ApiErrors").ApiServiceError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly deleteImposter: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly urlParams: {
+                readonly force: boolean;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly message: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly deletedAt: import("effect/DateTime").Utc;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly message: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly deletedAt: import("effect/DateTime").Utc;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("../api/ApiErrors").ApiConflictError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly addStub: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+            };
+            readonly payload: {
+                readonly predicates: readonly {
+                    readonly field: "method" | "headers" | "body" | "path" | "query";
+                    readonly value: unknown;
+                    readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                    readonly caseSensitive: boolean;
+                }[];
+                readonly responses: readonly [{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }, ...{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }[]];
+                readonly responseMode: "sequential" | "random" | "repeat";
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly listStubs: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }[], import("@effect/platform/HttpClientResponse").HttpClientResponse] : readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }[], import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly updateStub: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+                readonly stubId: string;
+            };
+            readonly payload: {
+                readonly predicates?: readonly {
+                    readonly field: "method" | "headers" | "body" | "path" | "query";
+                    readonly value: unknown;
+                    readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                    readonly caseSensitive: boolean;
+                }[] | undefined;
+                readonly responses?: readonly [{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }, ...{
+                    readonly headers?: {
+                        readonly [x: string]: string;
+                    } | undefined;
+                    readonly body?: unknown;
+                    readonly status: number;
+                    readonly delay?: number | undefined;
+                }[]] | undefined;
+                readonly responseMode?: "sequential" | "random" | "repeat" | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly deleteStub: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly imposterId: string;
+                readonly stubId: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly predicates: readonly {
+                readonly field: "method" | "headers" | "body" | "path" | "query";
+                readonly value: unknown;
+                readonly operator: "equals" | "contains" | "startsWith" | "matches" | "exists";
+                readonly caseSensitive: boolean;
+            }[];
+            readonly responses: readonly [{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }, ...{
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly body?: unknown;
+                readonly status: number;
+                readonly delay?: number | undefined;
+            }[]];
+            readonly responseMode: "sequential" | "random" | "repeat";
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly listRequests: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly urlParams: {
+                readonly method?: string | undefined;
+                readonly limit: number;
+                readonly path?: string | undefined;
+                readonly status?: number | undefined;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly response: {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: string | undefined;
+                readonly status: number;
+                readonly matchedStubId?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly proxied: boolean;
+            };
+            readonly timestamp: import("effect/DateTime").Utc;
+            readonly imposterId: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly request: {
+                readonly method: string;
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: unknown;
+                readonly path: string;
+                readonly query: {
+                    readonly [x: string]: string;
+                };
+            };
+            readonly duration: number;
+        }[], import("@effect/platform/HttpClientResponse").HttpClientResponse] : readonly {
+            readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly response: {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: string | undefined;
+                readonly status: number;
+                readonly matchedStubId?: (string & import("effect/Brand").Brand<"NonEmptyString">) | undefined;
+                readonly proxied: boolean;
+            };
+            readonly timestamp: import("effect/DateTime").Utc;
+            readonly imposterId: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly request: {
+                readonly method: string;
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body?: unknown;
+                readonly path: string;
+                readonly query: {
+                    readonly [x: string]: string;
+                };
+            };
+            readonly duration: number;
+        }[], import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly clearRequests: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly message: string;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly message: string;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly getImposterStats: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly totalRequests: number;
+            readonly requestsPerMinute: number;
+            readonly averageResponseTime: number;
+            readonly errorRate: number;
+            readonly requestsByMethod: {
+                readonly [x: string]: number;
+            };
+            readonly requestsByStatusCode: {
+                readonly [x: string]: number;
+            };
+            readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+            readonly p50ResponseTime?: number | undefined;
+            readonly p95ResponseTime?: number | undefined;
+            readonly p99ResponseTime?: number | undefined;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly totalRequests: number;
+            readonly requestsPerMinute: number;
+            readonly averageResponseTime: number;
+            readonly errorRate: number;
+            readonly requestsByMethod: {
+                readonly [x: string]: number;
+            };
+            readonly requestsByStatusCode: {
+                readonly [x: string]: number;
+            };
+            readonly lastRequestAt?: import("effect/DateTime").Utc | undefined;
+            readonly p50ResponseTime?: number | undefined;
+            readonly p95ResponseTime?: number | undefined;
+            readonly p99ResponseTime?: number | undefined;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+        readonly resetImposterStats: <WithResponse extends boolean = false>(request: {
+            readonly path: {
+                readonly id: string;
+            };
+            readonly withResponse?: WithResponse;
+        }) => Effect.Effect<WithResponse extends true ? [{
+            readonly message: string;
+        }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+            readonly message: string;
+        }, import("@effect/platform/HttpClientError").HttpClientError | import("../api/ApiErrors").ApiNotFoundError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+    };
+    readonly healthCheck: <WithResponse extends boolean = false>(request: void | {
+        readonly withResponse?: WithResponse;
+    }) => Effect.Effect<WithResponse extends true ? [{
+        readonly status: "healthy" | "unhealthy";
+        readonly uptime: string;
+        readonly timestamp: import("effect/DateTime").Utc;
+        readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+        readonly system: {
+            readonly imposters: {
+                readonly running: number;
+                readonly stopped: number;
+                readonly total: number;
+            };
+            readonly memory: {
+                readonly used: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly free: string & import("effect/Brand").Brand<"NonEmptyString">;
+            };
+            readonly ports: {
+                readonly available: number;
+                readonly allocated: number;
+            };
+        };
+    }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+        readonly status: "healthy" | "unhealthy";
+        readonly uptime: string;
+        readonly timestamp: import("effect/DateTime").Utc;
+        readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+        readonly system: {
+            readonly imposters: {
+                readonly running: number;
+                readonly stopped: number;
+                readonly total: number;
+            };
+            readonly memory: {
+                readonly used: string & import("effect/Brand").Brand<"NonEmptyString">;
+                readonly free: string & import("effect/Brand").Brand<"NonEmptyString">;
+            };
+            readonly ports: {
+                readonly available: number;
+                readonly allocated: number;
+            };
+        };
+    }, import("@effect/platform/HttpClientError").HttpClientError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+    readonly serverInfo: <WithResponse extends boolean = false>(request: void | {
+        readonly withResponse?: WithResponse;
+    }) => Effect.Effect<WithResponse extends true ? [{
+        readonly server: {
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly buildTime: import("effect/DateTime").Utc;
+            readonly platform: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly protocols: readonly "HTTP"[];
+        };
+        readonly configuration: {
+            readonly maxImposters: number;
+            readonly portRange: {
+                readonly min: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly max: number & import("effect/Brand").Brand<"PortNumber">;
+            };
+            readonly defaultTimeout: number;
+            readonly logLevel: "error" | "debug" | "info" | "warn";
+        };
+        readonly features: {
+            readonly openApiGeneration: boolean;
+            readonly clientGeneration: boolean;
+            readonly authentication: boolean;
+            readonly clustering: boolean;
+        };
+    }, import("@effect/platform/HttpClientResponse").HttpClientResponse] : {
+        readonly server: {
+            readonly name: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly version: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly buildTime: import("effect/DateTime").Utc;
+            readonly platform: string & import("effect/Brand").Brand<"NonEmptyString">;
+            readonly protocols: readonly "HTTP"[];
+        };
+        readonly configuration: {
+            readonly maxImposters: number;
+            readonly portRange: {
+                readonly min: number & import("effect/Brand").Brand<"PortNumber">;
+                readonly max: number & import("effect/Brand").Brand<"PortNumber">;
+            };
+            readonly defaultTimeout: number;
+            readonly logLevel: "error" | "debug" | "info" | "warn";
+        };
+        readonly features: {
+            readonly openApiGeneration: boolean;
+            readonly clientGeneration: boolean;
+            readonly authentication: boolean;
+            readonly clustering: boolean;
+        };
+    }, import("@effect/platform/HttpClientError").HttpClientError | import("@effect/platform/HttpApiError").HttpApiDecodeError | import("effect/ParseResult").ParseError, never>;
+}>;
+export declare class ImpostersClient extends ImpostersClient_base {
+}
+export declare const ImpostersClientLive: (baseUrl?: string) => Layer.Layer<ImpostersClient, never, HttpClient.HttpClient>;
+export declare const ImpostersClientFetchLive: (baseUrl?: string) => Layer.Layer<ImpostersClient>;
+export {};
+//# sourceMappingURL=ImpostersClient.d.ts.map