imposters 0.1.0

package/dist/dts/api/AdminApi.d.ts

@@ -0,0 +1,490 @@
+import { HttpApi } from "@effect/platform";
+export declare const AdminApi: HttpApi.HttpApi<"admin", import("@effect/platform/HttpApiGroup").HttpApiGroup<"imposters", import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"createImposter", "POST", never, never, {
+    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;
+}, never, {
+    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("./ApiErrors").ApiConflictError | import("./ApiErrors").ApiServiceError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"listImposters", "GET", never, {
+    readonly limit: number;
+    readonly offset: number;
+    readonly status?: "running" | "stopped" | "starting" | "stopping" | undefined;
+    readonly protocol?: "HTTP" | undefined;
+}, never, never, {
+    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;
+    }[];
+}, never, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"getImposter", "GET", {
+    readonly id: string;
+}, never, never, never, {
+    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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"updateImposter", "PATCH", {
+    readonly id: string;
+}, never, {
+    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;
+}, never, {
+    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("./ApiErrors").ApiNotFoundError | import("./ApiErrors").ApiConflictError | import("./ApiErrors").ApiServiceError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"deleteImposter", "DELETE", {
+    readonly id: string;
+}, {
+    readonly force: boolean;
+}, never, never, {
+    readonly message: string & import("effect/Brand").Brand<"NonEmptyString">;
+    readonly id: string & import("effect/Brand").Brand<"NonEmptyString">;
+    readonly deletedAt: import("effect/DateTime").Utc;
+}, import("./ApiErrors").ApiNotFoundError | import("./ApiErrors").ApiConflictError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"addStub", "POST", {
+    readonly imposterId: string;
+}, never, {
+    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";
+}, never, {
+    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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"listStubs", "GET", {
+    readonly imposterId: string;
+}, never, never, never, 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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"updateStub", "PUT", {
+    readonly imposterId: string;
+    readonly stubId: string;
+}, never, {
+    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;
+}, never, {
+    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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"deleteStub", "DELETE", {
+    readonly imposterId: string;
+    readonly stubId: string;
+}, never, never, never, {
+    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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"listRequests", "GET", {
+    readonly id: string;
+}, {
+    readonly method?: string | undefined;
+    readonly limit: number;
+    readonly path?: string | undefined;
+    readonly status?: number | undefined;
+}, never, never, 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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"clearRequests", "DELETE", {
+    readonly id: string;
+}, never, never, never, {
+    readonly message: string;
+}, import("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"getImposterStats", "GET", {
+    readonly id: string;
+}, never, never, never, {
+    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("./ApiErrors").ApiNotFoundError, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"resetImposterStats", "DELETE", {
+    readonly id: string;
+}, never, never, never, {
+    readonly message: string;
+}, import("./ApiErrors").ApiNotFoundError, never, never>, never, never, false> | import("@effect/platform/HttpApiGroup").HttpApiGroup<"system", import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"healthCheck", "GET", never, never, never, never, {
+    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;
+        };
+    };
+}, never, never, never> | import("@effect/platform/HttpApiEndpoint").HttpApiEndpoint<"serverInfo", "GET", never, never, never, never, {
+    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;
+    };
+}, never, never, never>, never, never, true>, import("@effect/platform/HttpApiError").HttpApiDecodeError, never>;
+//# sourceMappingURL=AdminApi.d.ts.map

package/dist/dts/api/AdminApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminApi.d.ts","sourceRoot":"","sources":["../../../src/api/AdminApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI1C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHAEF,CAAA"}

package/dist/dts/api/ApiErrors.d.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+declare const ApiNotFoundError_base: Schema.TaggedErrorClass<ApiNotFoundError, "ApiNotFoundError", {
+    readonly _tag: Schema.tag<"ApiNotFoundError">;
+} & {
+    message: typeof Schema.String;
+    resourceType: typeof Schema.String;
+    resourceId: typeof Schema.String;
+}>;
+export declare class ApiNotFoundError extends ApiNotFoundError_base {
+}
+declare const ApiConflictError_base: Schema.TaggedErrorClass<ApiConflictError, "ApiConflictError", {
+    readonly _tag: Schema.tag<"ApiConflictError">;
+} & {
+    message: typeof Schema.String;
+}>;
+export declare class ApiConflictError extends ApiConflictError_base {
+}
+declare const ApiServiceError_base: Schema.TaggedErrorClass<ApiServiceError, "ApiServiceError", {
+    readonly _tag: Schema.tag<"ApiServiceError">;
+} & {
+    message: typeof Schema.String;
+}>;
+export declare class ApiServiceError extends ApiServiceError_base {
+}
+export {};
+//# sourceMappingURL=ApiErrors.d.ts.map

package/dist/dts/api/ApiErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiErrors.d.ts","sourceRoot":"","sources":["../../../src/api/ApiErrors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;;;;;AAEvC,qBAAa,gBAAiB,SAAQ,qBAIrC;CAAG;;;;;;AAEJ,qBAAa,gBAAiB,SAAQ,qBAIrC;CAAG;;;;;;AAEJ,qBAAa,eAAgB,SAAQ,oBAIpC;CAAG"}

package/dist/dts/api/ApiSchemas.d.ts

@@ -0,0 +1,36 @@
+import * as Schema from "effect/Schema";
+export declare const PaginationUrlParams: Schema.Struct<{
+    limit: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.NumberFromString>>, {
+        default: () => number;
+    }>;
+    offset: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.NumberFromString>>, {
+        default: () => number;
+    }>;
+}>;
+export declare const ListImpostersUrlParams: Schema.Struct<{
+    status: Schema.optional<Schema.Literal<["running", "stopped", "starting", "stopping"]>>;
+    protocol: Schema.optional<Schema.Literal<["HTTP"]>>;
+    limit: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.NumberFromString>>, {
+        default: () => number;
+    }>;
+    offset: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.NumberFromString>>, {
+        default: () => number;
+    }>;
+}>;
+export type ListImpostersUrlParams = Schema.Schema.Type<typeof ListImpostersUrlParams>;
+export declare const DeleteImposterUrlParams: Schema.Struct<{
+    force: Schema.optionalWith<typeof Schema.BooleanFromString, {
+        default: () => false;
+    }>;
+}>;
+export type DeleteImposterUrlParams = Schema.Schema.Type<typeof DeleteImposterUrlParams>;
+export declare const ListRequestsUrlParams: Schema.Struct<{
+    limit: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.NumberFromString>>, {
+        default: () => number;
+    }>;
+    method: Schema.optional<typeof Schema.String>;
+    path: Schema.optional<typeof Schema.String>;
+    status: Schema.optional<typeof Schema.NumberFromString>;
+}>;
+export type ListRequestsUrlParams = Schema.Schema.Type<typeof ListRequestsUrlParams>;
+//# sourceMappingURL=ApiSchemas.d.ts.map

package/dist/dts/api/ApiSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiSchemas.d.ts","sourceRoot":"","sources":["../../../src/api/ApiSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,eAAO,MAAM,mBAAmB;;;;;;;EAS9B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;EAIjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEtF,eAAO,MAAM,uBAAuB;;;;EAElC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExF,eAAO,MAAM,qBAAqB;;;;;;;EAQhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/dts/api/Conversions.d.ts

@@ -0,0 +1,7 @@
+import * as Effect from "effect/Effect";
+import type { ImposterRecord } from "../repositories/ImposterRepository";
+import { type PaginationMeta } from "../schemas/common";
+import type { ImposterResponse } from "../schemas/ImposterSchema";
+export declare const toImposterResponse: (record: ImposterRecord) => Effect.Effect<ImposterResponse>;
+export declare const buildPaginationMeta: (total: number, limit: number, offset: number) => PaginationMeta;
+//# sourceMappingURL=Conversions.d.ts.map

package/dist/dts/api/Conversions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Conversions.d.ts","sourceRoot":"","sources":["../../../src/api/Conversions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAkB,KAAK,cAAc,EAA+B,MAAM,mBAAmB,CAAA;AACpG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,eAAO,MAAM,kBAAkB,GAAI,QAAQ,cAAc,KAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAkBtF,CAAA;AAEJ,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,cAKjF,CAAA"}