@liase/core 1.0.0

package/dist/schemas/plugin.d.ts

@@ -0,0 +1,298 @@
+import { z } from "zod";
+export declare const pluginSchema: z.ZodObject<{
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        description: z.ZodString;
+        requestHandlers: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            displayName: z.ZodString;
+            description: z.ZodString;
+            requestSchema: z.ZodType<z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>, z.ZodTypeDef, z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>>;
+            secretsSchema: z.ZodOptional<z.ZodType<z.AnyZodObject, z.ZodTypeDef, z.AnyZodObject>>;
+            paginationType: z.ZodDefault<z.ZodEnum<["offset", "cursor", "none"]>>;
+            responses: z.ZodArray<z.ZodObject<{
+                requestMatcher: z.ZodOptional<z.ZodType<z.AnyZodObject, z.ZodTypeDef, z.AnyZodObject>>;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodType<z.AnyZodObject, z.ZodTypeDef, z.AnyZodObject>;
+                constructor: z.ZodType<import("./constructor.js").Constructor, z.ZodTypeDef, import("./constructor.js").Constructor>;
+            }, "strict", z.ZodTypeAny, {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }, {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            displayName: string;
+            description: string;
+            requestSchema: z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>;
+            paginationType: "cursor" | "offset" | "none";
+            responses: {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }[];
+            secretsSchema?: z.AnyZodObject | undefined;
+        }, {
+            id: string;
+            displayName: string;
+            description: string;
+            requestSchema: z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>;
+            responses: {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }[];
+            secretsSchema?: z.AnyZodObject | undefined;
+            paginationType?: "cursor" | "offset" | "none" | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        displayName: string;
+        description: string;
+        requestHandlers: {
+            id: string;
+            displayName: string;
+            description: string;
+            requestSchema: z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>;
+            paginationType: "cursor" | "offset" | "none";
+            responses: {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }[];
+            secretsSchema?: z.AnyZodObject | undefined;
+        }[];
+    }, {
+        id: string;
+        displayName: string;
+        description: string;
+        requestHandlers: {
+            id: string;
+            displayName: string;
+            description: string;
+            requestSchema: z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>;
+            responses: {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }[];
+            secretsSchema?: z.AnyZodObject | undefined;
+            paginationType?: "cursor" | "offset" | "none" | undefined;
+        }[];
+    }>, "many">>;
+    hooks: z.ZodOptional<z.ZodObject<{
+        loadUrl: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>>;
+        getFetchClient: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>>;
+    }, "strict", z.ZodTypeAny, {
+        loadUrl?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+        getFetchClient?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+    }, {
+        loadUrl?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+        getFetchClient?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    hooks?: {
+        loadUrl?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+        getFetchClient?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+    } | undefined;
+    sources?: {
+        id: string;
+        displayName: string;
+        description: string;
+        requestHandlers: {
+            id: string;
+            displayName: string;
+            description: string;
+            requestSchema: z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>;
+            paginationType: "cursor" | "offset" | "none";
+            responses: {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }[];
+            secretsSchema?: z.AnyZodObject | undefined;
+        }[];
+    }[] | undefined;
+}, {
+    hooks?: {
+        loadUrl?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+        getFetchClient?: ((args_0: any, args_1: (args_0: any, ...args: unknown[]) => Promise<any>, ...args: unknown[]) => Promise<any>) | undefined;
+    } | undefined;
+    sources?: {
+        id: string;
+        displayName: string;
+        description: string;
+        requestHandlers: {
+            id: string;
+            displayName: string;
+            description: string;
+            requestSchema: z.ZodObject<{
+                source: z.ZodString;
+                queryType: z.ZodString;
+                pageNumber?: z.ZodTypeAny;
+                cursor?: z.ZodTypeAny;
+            }, "strict", z.ZodTypeAny, Omit<{
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }, "pageNumber" | "cursor"> & {
+                pageNumber?: number;
+                cursor?: string | number | null;
+            }, {
+                source: string;
+                queryType: string;
+                pageNumber?: unknown;
+                cursor?: unknown;
+            }>;
+            responses: {
+                schema: z.AnyZodObject;
+                description?: string | undefined;
+                requestMatcher?: z.AnyZodObject | undefined;
+                constructor?: import("./constructor.js").Constructor;
+            }[];
+            secretsSchema?: z.AnyZodObject | undefined;
+            paginationType?: "cursor" | "offset" | "none" | undefined;
+        }[];
+    }[] | undefined;
+}>;
+export type Plugin = z.infer<typeof pluginSchema>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/schemas/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/schemas/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWd,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/schemas/plugin.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { sourceSchema } from "./source.js";
+const hookSchema = z
+    .function()
+    .args(z.any(), z.function().args(z.any()).returns(z.promise(z.any())))
+    .returns(z.promise(z.any()))
+    .optional();
+export const pluginSchema = z
+    .object({
+    sources: sourceSchema.array().optional(),
+    hooks: z
+        .object({
+        loadUrl: hookSchema,
+        getFetchClient: hookSchema,
+    })
+        .strict()
+        .optional(),
+})
+    .strict();

package/dist/schemas/primitives.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const zodPrimitives: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt, z.ZodBoolean, z.ZodDate, z.ZodSymbol, z.ZodUndefined, z.ZodNull]>;
+export type Primitives = z.infer<typeof zodPrimitives>;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/schemas/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../src/schemas/primitives.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa,sHASxB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas/primitives.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const zodPrimitives = z.union([
+    z.string(),
+    z.number(),
+    z.bigint(),
+    z.boolean(),
+    z.date(),
+    z.symbol(),
+    z.undefined(),
+    z.null(),
+]);

package/dist/schemas/queryOptions.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const queryOptionsSchema: z.ZodObject<{
+    secrets: z.ZodDefault<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    fetchCountLimit: z.ZodDefault<z.ZodNumber>;
+    cacheNetworkRequests: z.ZodOptional<z.ZodEnum<["never", "auto", "always"]>>;
+}, "strict", z.ZodTypeAny, {
+    secrets: {} & {
+        [k: string]: unknown;
+    };
+    fetchCountLimit: number;
+    cacheNetworkRequests?: "never" | "auto" | "always" | undefined;
+}, {
+    secrets?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    fetchCountLimit?: number | undefined;
+    cacheNetworkRequests?: "never" | "auto" | "always" | undefined;
+}>;
+export type QueryOptions = z.infer<typeof queryOptionsSchema>;
+export type QueryOptionsInput = z.input<typeof queryOptionsSchema>;
+//# sourceMappingURL=queryOptions.d.ts.map

package/dist/schemas/queryOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryOptions.d.ts","sourceRoot":"","sources":["../../src/schemas/queryOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;EAMpB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/schemas/queryOptions.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { genericSecretsSchema } from "./secrets.js";
+export const queryOptionsSchema = z
+    .object({
+    secrets: genericSecretsSchema.default({}),
+    fetchCountLimit: z.number().int().default(10),
+    cacheNetworkRequests: z.enum(["never", "auto", "always"]).optional(),
+})
+    .strict();

package/dist/schemas/request.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+export declare const genericRequestSchema: z.ZodObject<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+    pageNumber: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+    pageNumber: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+    pageNumber: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const genericPaginationOffsetRequestSchema: z.ZodObject<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    pageNumber: z.ZodNumber;
+    cursor: z.ZodNever;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    pageNumber: z.ZodNumber;
+    cursor: z.ZodNever;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    pageNumber: z.ZodNumber;
+    cursor: z.ZodNever;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const genericPaginationCursorRequestSchema: z.ZodObject<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    cursor: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;
+    pageNumber: z.ZodNever;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    cursor: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;
+    pageNumber: z.ZodNever;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    cursor: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;
+    pageNumber: z.ZodNever;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const genericPaginationNoneRequestSchema: z.ZodObject<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    cursor: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;
+    pageNumber: z.ZodNever;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    cursor: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;
+    pageNumber: z.ZodNever;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodString;
+    queryType: z.ZodString;
+} & {
+    cursor: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;
+    pageNumber: z.ZodNever;
+}, z.ZodTypeAny, "passthrough">>;
+export type GenericRequest = z.infer<typeof genericRequestSchema>;
+export type GenericRequestInput = z.input<typeof genericRequestSchema>;
+//# sourceMappingURL=request.d.ts.map

package/dist/schemas/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/schemas/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;gCAOjB,CAAC;AAEjB,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;gCAKhD,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;gCAKhD,CAAC;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;gCAG7C,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/request.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const genericRequestSchema = z
+    .object({
+    source: z.string().regex(/^[a-z-]+$/),
+    queryType: z.string().regex(/^[a-z-]+$/),
+    pageNumber: z.number().optional(),
+    cursor: z.union([z.string(), z.number(), z.null()]).optional(),
+})
+    .passthrough();
+export const genericPaginationOffsetRequestSchema = genericRequestSchema.extend({
+    pageNumber: genericRequestSchema.shape.pageNumber.unwrap(),
+    cursor: z.never(),
+});
+export const genericPaginationCursorRequestSchema = genericRequestSchema.extend({
+    cursor: genericRequestSchema.shape.cursor.unwrap(),
+    pageNumber: z.never(),
+});
+export const genericPaginationNoneRequestSchema = genericRequestSchema.extend({
+    cursor: genericRequestSchema.shape.cursor.unwrap(),
+    pageNumber: z.never(),
+});

package/dist/schemas/requestHandler.d.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+export declare const requestHandlerSchema: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodString;
+    requestSchema: z.ZodType<z.ZodObject<{
+        source: z.ZodString;
+        queryType: z.ZodString;
+        pageNumber?: z.ZodTypeAny;
+        cursor?: z.ZodTypeAny;
+    }, "strict", z.ZodTypeAny, Omit<{
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }, "pageNumber" | "cursor"> & {
+        pageNumber?: number;
+        cursor?: string | number | null;
+    }, {
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }>, z.ZodTypeDef, z.ZodObject<{
+        source: z.ZodString;
+        queryType: z.ZodString;
+        pageNumber?: z.ZodTypeAny;
+        cursor?: z.ZodTypeAny;
+    }, "strict", z.ZodTypeAny, Omit<{
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }, "pageNumber" | "cursor"> & {
+        pageNumber?: number;
+        cursor?: string | number | null;
+    }, {
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }>>;
+    secretsSchema: z.ZodOptional<z.ZodType<z.AnyZodObject, z.ZodTypeDef, z.AnyZodObject>>;
+    paginationType: z.ZodDefault<z.ZodEnum<["offset", "cursor", "none"]>>;
+    responses: z.ZodArray<z.ZodObject<{
+        requestMatcher: z.ZodOptional<z.ZodType<z.AnyZodObject, z.ZodTypeDef, z.AnyZodObject>>;
+        description: z.ZodOptional<z.ZodString>;
+        schema: z.ZodType<z.AnyZodObject, z.ZodTypeDef, z.AnyZodObject>;
+        constructor: z.ZodType<import("./constructor.js").Constructor, z.ZodTypeDef, import("./constructor.js").Constructor>;
+    }, "strict", z.ZodTypeAny, {
+        schema: z.AnyZodObject;
+        description?: string | undefined;
+        requestMatcher?: z.AnyZodObject | undefined;
+        constructor?: import("./constructor.js").Constructor;
+    }, {
+        schema: z.AnyZodObject;
+        description?: string | undefined;
+        requestMatcher?: z.AnyZodObject | undefined;
+        constructor?: import("./constructor.js").Constructor;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    displayName: string;
+    description: string;
+    requestSchema: z.ZodObject<{
+        source: z.ZodString;
+        queryType: z.ZodString;
+        pageNumber?: z.ZodTypeAny;
+        cursor?: z.ZodTypeAny;
+    }, "strict", z.ZodTypeAny, Omit<{
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }, "pageNumber" | "cursor"> & {
+        pageNumber?: number;
+        cursor?: string | number | null;
+    }, {
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }>;
+    paginationType: "cursor" | "offset" | "none";
+    responses: {
+        schema: z.AnyZodObject;
+        description?: string | undefined;
+        requestMatcher?: z.AnyZodObject | undefined;
+        constructor?: import("./constructor.js").Constructor;
+    }[];
+    secretsSchema?: z.AnyZodObject | undefined;
+}, {
+    id: string;
+    displayName: string;
+    description: string;
+    requestSchema: z.ZodObject<{
+        source: z.ZodString;
+        queryType: z.ZodString;
+        pageNumber?: z.ZodTypeAny;
+        cursor?: z.ZodTypeAny;
+    }, "strict", z.ZodTypeAny, Omit<{
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }, "pageNumber" | "cursor"> & {
+        pageNumber?: number;
+        cursor?: string | number | null;
+    }, {
+        source: string;
+        queryType: string;
+        pageNumber?: unknown;
+        cursor?: unknown;
+    }>;
+    responses: {
+        schema: z.AnyZodObject;
+        description?: string | undefined;
+        requestMatcher?: z.AnyZodObject | undefined;
+        constructor?: import("./constructor.js").Constructor;
+    }[];
+    secretsSchema?: z.AnyZodObject | undefined;
+    paginationType?: "cursor" | "offset" | "none" | undefined;
+}>;
+export type RequestHandler = z.infer<typeof requestHandlerSchema>;
+export type RequestHandlerInput = z.input<typeof requestHandlerSchema>;
+//# sourceMappingURL=requestHandler.d.ts.map

package/dist/schemas/requestHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestHandler.d.ts","sourceRoot":"","sources":["../../src/schemas/requestHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,oBAAoB;;;;;gBAQf,CAAC,CAAC,SAAS;mBACR,CAAC,CAAC,SAAS;qBACT,CAAC,CAAC,UAAU;iBAChB,CAAC,CAAC,UAAU;;;;;;;qBAiBR,MAAM;iBACV,MAAM,GAAG,MAAM,GAAG,IAAI;;;;;;;gBArBvB,CAAC,CAAC,SAAS;mBACR,CAAC,CAAC,SAAS;qBACT,CAAC,CAAC,UAAU;iBAChB,CAAC,CAAC,UAAU;;;;;;;qBAiBR,MAAM;iBACV,MAAM,GAAG,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBArBvB,CAAC,CAAC,SAAS;mBACR,CAAC,CAAC,SAAS;qBACT,CAAC,CAAC,UAAU;iBAChB,CAAC,CAAC,UAAU;;;;;;;qBAiBR,MAAM;iBACV,MAAM,GAAG,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;gBArBvB,CAAC,CAAC,SAAS;mBACR,CAAC,CAAC,SAAS;qBACT,CAAC,CAAC,UAAU;iBAChB,CAAC,CAAC,UAAU;;;;;;;qBAiBR,MAAM;iBACV,MAAM,GAAG,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;EA2B9B,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/requestHandler.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { ConstructorSchema } from "./constructor.js";
+export const requestHandlerSchema = z
+    .object({
+    id: z.string().regex(/^[a-z-]+$/),
+    displayName: z.string(),
+    description: z.string(),
+    requestSchema: z.custom((val) => val?.constructor?.name === "ZodObject"),
+    secretsSchema: z
+        .custom((val) => val?.constructor?.name === "ZodObject")
+        .optional(),
+    paginationType: z.enum(["offset", "cursor", "none"]).default("none"),
+    responses: z
+        .array(z
+        .object({
+        requestMatcher: z
+            .custom((val) => val?.constructor?.name === "ZodObject")
+            .optional(),
+        description: z.string().optional(),
+        schema: z.custom((val) => val?.constructor?.name === "ZodObject"),
+        constructor: ConstructorSchema,
+    })
+        .strict())
+        .min(1),
+})
+    .strict();