@vistagenic/vista 0.2.16 → 0.3.0

package/dist/stack/server/executor.js

@@ -1,174 +1,222 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StackValidationError = exports.StackMethodNotAllowedError = exports.StackRouteNotFoundError = void 0;
-exports.createResponseToolkit = createResponseToolkit;
-exports.runMiddlewareChain = runMiddlewareChain;
-exports.executeOperation = executeOperation;
-exports.executeRoute = executeRoute;
-const serialization_1 = require("./serialization");
-const router_1 = require("./router");
-function isObjectRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function normalizeResponseInit(init) {
-    if (typeof init === 'number') {
-        return { status: init };
-    }
-    return init ?? {};
-}
-class StackRouteNotFoundError extends Error {
-    status = 404;
-    constructor(path) {
-        super(`No typed API route found for "${path}"`);
-        this.name = 'StackRouteNotFoundError';
-    }
-}
-exports.StackRouteNotFoundError = StackRouteNotFoundError;
-class StackMethodNotAllowedError extends Error {
-    status = 405;
-    constructor(path, method) {
-        super(`Method "${method.toUpperCase()}" is not allowed for "${path}"`);
-        this.name = 'StackMethodNotAllowedError';
-    }
-}
-exports.StackMethodNotAllowedError = StackMethodNotAllowedError;
-class StackValidationError extends Error {
-    status = 400;
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.name = 'StackValidationError';
-        this.cause = cause;
-    }
-}
-exports.StackValidationError = StackValidationError;
-function createResponseToolkit(mode = 'json') {
-    return {
-        json(data, init) {
-            const payload = (0, serialization_1.serializeWithMode)(data, 'json');
-            return Response.json(payload, normalizeResponseInit(init));
-        },
-        text(data, init) {
-            return new Response(String(data), normalizeResponseInit(init));
-        },
-        superjson(data, init) {
-            const payload = {
-                mode: 'superjson',
-                data: (0, serialization_1.serializeWithMode)(data, 'superjson'),
-            };
-            return Response.json(payload, normalizeResponseInit(init));
-        },
-    };
-}
-async function runMiddlewareChain(middlewares, context, env, req, c) {
-    const executeAt = async (index, currentContext) => {
-        if (index >= middlewares.length) {
-            return currentContext;
-        }
-        const middleware = middlewares[index];
-        let nextCalled = false;
-        let nextContextPromise;
-        const next = async (extension = {}) => {
-            if (nextCalled) {
-                throw new Error('next() can only be called once per middleware');
-            }
-            nextCalled = true;
-            const mergedContext = isObjectRecord(extension) && isObjectRecord(currentContext)
-                ? { ...currentContext, ...extension }
-                : currentContext;
-            nextContextPromise = executeAt(index + 1, mergedContext);
-            return nextContextPromise;
-        };
-        const result = await middleware({
-            ctx: currentContext,
-            env,
-            req,
-            c,
-            next,
-        });
-        if (nextCalled) {
-            const downstreamContext = await nextContextPromise;
-            if (isObjectRecord(result) && isObjectRecord(downstreamContext)) {
-                return { ...downstreamContext, ...result };
-            }
-            return downstreamContext;
-        }
-        if (isObjectRecord(result) && isObjectRecord(currentContext)) {
-            return executeAt(index + 1, { ...currentContext, ...result });
-        }
-        return executeAt(index + 1, currentContext);
-    };
-    return (await executeAt(0, context));
-}
-function resolveRawInput(operation, req) {
-    if (operation.type === 'get') {
-        if (req.query !== undefined) {
-            return req.query;
-        }
-        return req.body;
-    }
-    if (req.body !== undefined) {
-        return req.body;
-    }
-    return req.query;
-}
-function resolveInput(operation, req, serialization) {
-    const rawInput = resolveRawInput(operation, req);
-    const input = (0, serialization_1.deserializeWithMode)(rawInput, serialization);
-    if (!operation.schema) {
-        return input;
-    }
-    try {
-        return operation.schema.parse(input);
-    }
-    catch (error) {
-        throw new StackValidationError('Invalid typed API input', error);
-    }
-}
-async function executeOperation(operation, options) {
-    const middlewareChain = [...(options.middlewares ?? []), ...operation.middlewares];
-    const finalContext = await runMiddlewareChain(middlewareChain, options.ctx, options.env, options.req, options.c);
-    const input = resolveInput(operation, options.req, options.serialization ?? 'json');
-    return operation.handler({
-        ctx: finalContext,
-        input,
-        env: options.env,
-        req: options.req,
-        c: options.c,
-    });
-}
-function hasPath(routes, path) {
-    return Object.prototype.hasOwnProperty.call(routes, path);
-}
-async function executeRoute(router, options) {
-    const normalizedPath = (0, router_1.normalizeStackRoutePath)(options.path);
-    const normalizedMethod = String(options.method).toLowerCase();
-    const routes = router.routes;
-    const candidateRoute = routes[normalizedPath];
-    if (!candidateRoute) {
-        throw new StackRouteNotFoundError(normalizedPath);
-    }
-    if (candidateRoute.type !== normalizedMethod) {
-        if (hasPath(routes, normalizedPath)) {
-            throw new StackMethodNotAllowedError(normalizedPath, normalizedMethod);
-        }
-        throw new StackRouteNotFoundError(normalizedPath);
-    }
-    const serialization = options.serialization ?? 'json';
-    const responseToolkit = createResponseToolkit(serialization);
-    const payload = await executeOperation(candidateRoute, {
-        ctx: options.ctx,
-        env: options.env,
-        req: options.req,
-        c: responseToolkit,
-        middlewares: router.metadata.globalMiddlewares,
-        serialization,
-    });
-    const serializedData = (0, serialization_1.serializeWithMode)(payload, serialization);
-    return {
-        path: normalizedPath,
-        method: normalizedMethod,
-        data: (0, serialization_1.deserializeWithMode)(payload, serialization),
-        serializedData,
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackOutputValidationError = exports.StackValidationError = exports.StackMethodNotAllowedError = exports.StackRouteNotFoundError = void 0;
+exports.createResponseToolkit = createResponseToolkit;
+exports.runMiddlewareChain = runMiddlewareChain;
+exports.executeOperation = executeOperation;
+exports.executeRoute = executeRoute;
+const serialization_1 = require("./serialization");
+const router_1 = require("./router");
+function isObjectRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeResponseInit(init) {
+    if (typeof init === 'number') {
+        return { status: init };
+    }
+    return init ?? {};
+}
+class StackRouteNotFoundError extends Error {
+    status = 404;
+    constructor(path) {
+        super(`No typed API route found for "${path}"`);
+        this.name = 'StackRouteNotFoundError';
+    }
+}
+exports.StackRouteNotFoundError = StackRouteNotFoundError;
+class StackMethodNotAllowedError extends Error {
+    status = 405;
+    constructor(path, method) {
+        super(`Method "${method.toUpperCase()}" is not allowed for "${path}"`);
+        this.name = 'StackMethodNotAllowedError';
+    }
+}
+exports.StackMethodNotAllowedError = StackMethodNotAllowedError;
+class StackValidationError extends Error {
+    status = 400;
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'StackValidationError';
+        this.cause = cause;
+    }
+}
+exports.StackValidationError = StackValidationError;
+class StackOutputValidationError extends StackValidationError {
+    status = 500;
+    constructor(message, cause) {
+        super(message, cause);
+        this.name = 'StackOutputValidationError';
+    }
+}
+exports.StackOutputValidationError = StackOutputValidationError;
+class StackMiddlewareResponse {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+}
+function isWebResponse(value) {
+    return typeof Response !== 'undefined' && value instanceof Response;
+}
+function createResponseToolkit(mode = 'json') {
+    return {
+        json(data, init) {
+            const payload = (0, serialization_1.serializeWithMode)(data, 'json');
+            return Response.json(payload, normalizeResponseInit(init));
+        },
+        text(data, init) {
+            return new Response(String(data), normalizeResponseInit(init));
+        },
+        superjson(data, init) {
+            const payload = {
+                mode: 'superjson',
+                data: (0, serialization_1.serializeWithMode)(data, 'superjson'),
+            };
+            return Response.json(payload, normalizeResponseInit(init));
+        },
+    };
+}
+async function runMiddlewareChain(middlewares, context, env, req, c) {
+    const executeAt = async (index, currentContext) => {
+        if (index >= middlewares.length) {
+            return currentContext;
+        }
+        const middleware = middlewares[index];
+        let nextCalled = false;
+        let nextContextPromise;
+        const next = async (extension = {}) => {
+            if (nextCalled) {
+                throw new Error('next() can only be called once per middleware');
+            }
+            nextCalled = true;
+            const mergedContext = isObjectRecord(extension) && isObjectRecord(currentContext)
+                ? { ...currentContext, ...extension }
+                : currentContext;
+            nextContextPromise = executeAt(index + 1, mergedContext);
+            return nextContextPromise;
+        };
+        const result = await middleware({
+            ctx: currentContext,
+            env,
+            req,
+            c,
+            next,
+        });
+        if (isWebResponse(result) && !nextCalled) {
+            throw new StackMiddlewareResponse(result);
+        }
+        if (nextCalled) {
+            const downstreamContext = await nextContextPromise;
+            if (isObjectRecord(result) && isObjectRecord(downstreamContext)) {
+                return { ...downstreamContext, ...result };
+            }
+            return downstreamContext;
+        }
+        if (isObjectRecord(result) && isObjectRecord(currentContext)) {
+            return executeAt(index + 1, { ...currentContext, ...result });
+        }
+        return executeAt(index + 1, currentContext);
+    };
+    return (await executeAt(0, context));
+}
+function resolveRawInput(operation, req) {
+    if (operation.type === 'get') {
+        if (req.query !== undefined) {
+            return req.query;
+        }
+        return req.body;
+    }
+    if (req.body !== undefined) {
+        return req.body;
+    }
+    return req.query;
+}
+function resolveInput(operation, req, serialization) {
+    const rawInput = resolveRawInput(operation, req);
+    const input = (0, serialization_1.deserializeWithMode)(rawInput, serialization);
+    if (!operation.schema) {
+        return input;
+    }
+    try {
+        return operation.schema.parse(input);
+    }
+    catch (error) {
+        throw new StackValidationError('Invalid typed API input', error);
+    }
+}
+function resolveOutput(operation, output) {
+    if (!operation.outputSchema || isWebResponse(output)) {
+        return output;
+    }
+    try {
+        return operation.outputSchema.parse(output);
+    }
+    catch (error) {
+        throw new StackOutputValidationError('Invalid typed API output', error);
+    }
+}
+async function executeOperation(operation, options) {
+    try {
+        const middlewareChain = [...(options.middlewares ?? []), ...operation.middlewares];
+        const finalContext = await runMiddlewareChain(middlewareChain, options.ctx, options.env, options.req, options.c);
+        const input = resolveInput(operation, options.req, options.serialization ?? 'json');
+        const output = await operation.handler({
+            ctx: finalContext,
+            input,
+            env: options.env,
+            req: options.req,
+            c: options.c,
+        });
+        return resolveOutput(operation, output);
+    }
+    catch (error) {
+        if (error instanceof StackMiddlewareResponse) {
+            return error.response;
+        }
+        throw error;
+    }
+}
+function hasPath(routes, path) {
+    return Object.prototype.hasOwnProperty.call(routes, path);
+}
+async function executeRoute(router, options) {
+    const normalizedPath = (0, router_1.normalizeStackRoutePath)(options.path);
+    const normalizedMethod = String(options.method).toLowerCase();
+    const routes = router.routes;
+    const candidateRoute = routes[normalizedPath];
+    if (!candidateRoute) {
+        throw new StackRouteNotFoundError(normalizedPath);
+    }
+    if (candidateRoute.type !== normalizedMethod) {
+        if (hasPath(routes, normalizedPath)) {
+            throw new StackMethodNotAllowedError(normalizedPath, normalizedMethod);
+        }
+        throw new StackRouteNotFoundError(normalizedPath);
+    }
+    const serialization = options.serialization ?? 'json';
+    const responseToolkit = createResponseToolkit(serialization);
+    const payload = await executeOperation(candidateRoute, {
+        ctx: options.ctx,
+        env: options.env,
+        req: options.req,
+        c: responseToolkit,
+        middlewares: router.metadata.globalMiddlewares,
+        serialization,
+    });
+    if (isWebResponse(payload)) {
+        return {
+            path: normalizedPath,
+            method: normalizedMethod,
+            data: payload,
+            serializedData: payload,
+        };
+    }
+    const serializedData = (0, serialization_1.serializeWithMode)(payload, serialization);
+    return {
+        path: normalizedPath,
+        method: normalizedMethod,
+        data: (0, serialization_1.deserializeWithMode)(payload, serialization),
+        serializedData,
+    };
+}

package/dist/stack/server/index.d.ts

@@ -1,10 +1,11 @@
-export { createProcedureBuilder, isOperation } from './procedure';
-export type { ProcedureBuilder } from './procedure';
-export { createRouter, normalizeStackRoutePath } from './router';
-export type { CreateRouterOptions } from './router';
-export { mergeRouters } from './merge-routers';
-export { createResponseToolkit, executeOperation, executeRoute, runMiddlewareChain, StackMethodNotAllowedError, StackRouteNotFoundError, StackValidationError, } from './executor';
-export type { ExecuteOperationOptions, ExecuteRouteOptions, ExecuteRouteResult, } from './executor';
-export { createSerializer, deserializeWithMode, serializeWithMode, } from './serialization';
-export type { StackSerializer } from './serialization';
-export type { FlatRouteMap, GetOperation, InferMiddlewareOutput, InferSchemaInput, MaybePromise, MiddlewareFunction, MiddlewareParams, NormalizeMiddlewareResult, OperationType, PostOperation, Prettify, ProcedureHandler, ProcedureHandlerParams, ProcedureNode, ProcedureRecord, ResolvedRoute, RouterMetadata, SchemaLike, StackErrorHandler, StackErrorWithStatus, StackExecutionContext, StackRequestLike, StackResponseToolkit, StackRouter, StackSerializationMode, } from './types';
+export { createProcedureBuilder, isOperation } from './procedure';
+export type { ProcedureBuilder } from './procedure';
+export { createRouter, normalizeStackRoutePath } from './router';
+export type { CreateRouterOptions } from './router';
+export { createCaller } from './caller';
+export type { CreateCallerOptions, InferCaller } from './caller';
+export { createResponseToolkit, executeOperation, executeRoute, runMiddlewareChain, StackMethodNotAllowedError, StackOutputValidationError, StackRouteNotFoundError, StackValidationError, } from './executor';
+export type { ExecuteOperationOptions, ExecuteRouteOptions, ExecuteRouteResult, } from './executor';
+export { createSerializer, deserializeWithMode, serializeWithMode, } from './serialization';
+export type { StackSerializer } from './serialization';
+export type { FlatRouteMap, GetOperation, InferMiddlewareOutput, InferSchemaInput, MaybePromise, MiddlewareFunction, MiddlewareParams, NormalizeMiddlewareResult, OperationType, PostOperation, Prettify, ProcedureHandler, ProcedureHandlerParams, ProcedureNode, ProcedureRecord, ResolvedRoute, RouterMetadata, SchemaLike, StackCookieStore, StackErrorHandler, StackErrorWithStatus, StackExecutionContext, StackRequestLike, StackResponseToolkit, StackRouter, StackSerializationMode, } from './types';

package/dist/stack/server/index.js

@@ -1,23 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeWithMode = exports.deserializeWithMode = exports.createSerializer = exports.StackValidationError = exports.StackRouteNotFoundError = exports.StackMethodNotAllowedError = exports.runMiddlewareChain = exports.executeRoute = exports.executeOperation = exports.createResponseToolkit = exports.mergeRouters = exports.normalizeStackRoutePath = exports.createRouter = exports.isOperation = exports.createProcedureBuilder = void 0;
-var procedure_1 = require("./procedure");
-Object.defineProperty(exports, "createProcedureBuilder", { enumerable: true, get: function () { return procedure_1.createProcedureBuilder; } });
-Object.defineProperty(exports, "isOperation", { enumerable: true, get: function () { return procedure_1.isOperation; } });
-var router_1 = require("./router");
-Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return router_1.createRouter; } });
-Object.defineProperty(exports, "normalizeStackRoutePath", { enumerable: true, get: function () { return router_1.normalizeStackRoutePath; } });
-var merge_routers_1 = require("./merge-routers");
-Object.defineProperty(exports, "mergeRouters", { enumerable: true, get: function () { return merge_routers_1.mergeRouters; } });
-var executor_1 = require("./executor");
-Object.defineProperty(exports, "createResponseToolkit", { enumerable: true, get: function () { return executor_1.createResponseToolkit; } });
-Object.defineProperty(exports, "executeOperation", { enumerable: true, get: function () { return executor_1.executeOperation; } });
-Object.defineProperty(exports, "executeRoute", { enumerable: true, get: function () { return executor_1.executeRoute; } });
-Object.defineProperty(exports, "runMiddlewareChain", { enumerable: true, get: function () { return executor_1.runMiddlewareChain; } });
-Object.defineProperty(exports, "StackMethodNotAllowedError", { enumerable: true, get: function () { return executor_1.StackMethodNotAllowedError; } });
-Object.defineProperty(exports, "StackRouteNotFoundError", { enumerable: true, get: function () { return executor_1.StackRouteNotFoundError; } });
-Object.defineProperty(exports, "StackValidationError", { enumerable: true, get: function () { return executor_1.StackValidationError; } });
-var serialization_1 = require("./serialization");
-Object.defineProperty(exports, "createSerializer", { enumerable: true, get: function () { return serialization_1.createSerializer; } });
-Object.defineProperty(exports, "deserializeWithMode", { enumerable: true, get: function () { return serialization_1.deserializeWithMode; } });
-Object.defineProperty(exports, "serializeWithMode", { enumerable: true, get: function () { return serialization_1.serializeWithMode; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWithMode = exports.deserializeWithMode = exports.createSerializer = exports.StackValidationError = exports.StackRouteNotFoundError = exports.StackOutputValidationError = exports.StackMethodNotAllowedError = exports.runMiddlewareChain = exports.executeRoute = exports.executeOperation = exports.createResponseToolkit = exports.createCaller = exports.normalizeStackRoutePath = exports.createRouter = exports.isOperation = exports.createProcedureBuilder = void 0;
+var procedure_1 = require("./procedure");
+Object.defineProperty(exports, "createProcedureBuilder", { enumerable: true, get: function () { return procedure_1.createProcedureBuilder; } });
+Object.defineProperty(exports, "isOperation", { enumerable: true, get: function () { return procedure_1.isOperation; } });
+var router_1 = require("./router");
+Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return router_1.createRouter; } });
+Object.defineProperty(exports, "normalizeStackRoutePath", { enumerable: true, get: function () { return router_1.normalizeStackRoutePath; } });
+var caller_1 = require("./caller");
+Object.defineProperty(exports, "createCaller", { enumerable: true, get: function () { return caller_1.createCaller; } });
+var executor_1 = require("./executor");
+Object.defineProperty(exports, "createResponseToolkit", { enumerable: true, get: function () { return executor_1.createResponseToolkit; } });
+Object.defineProperty(exports, "executeOperation", { enumerable: true, get: function () { return executor_1.executeOperation; } });
+Object.defineProperty(exports, "executeRoute", { enumerable: true, get: function () { return executor_1.executeRoute; } });
+Object.defineProperty(exports, "runMiddlewareChain", { enumerable: true, get: function () { return executor_1.runMiddlewareChain; } });
+Object.defineProperty(exports, "StackMethodNotAllowedError", { enumerable: true, get: function () { return executor_1.StackMethodNotAllowedError; } });
+Object.defineProperty(exports, "StackOutputValidationError", { enumerable: true, get: function () { return executor_1.StackOutputValidationError; } });
+Object.defineProperty(exports, "StackRouteNotFoundError", { enumerable: true, get: function () { return executor_1.StackRouteNotFoundError; } });
+Object.defineProperty(exports, "StackValidationError", { enumerable: true, get: function () { return executor_1.StackValidationError; } });
+var serialization_1 = require("./serialization");
+Object.defineProperty(exports, "createSerializer", { enumerable: true, get: function () { return serialization_1.createSerializer; } });
+Object.defineProperty(exports, "deserializeWithMode", { enumerable: true, get: function () { return serialization_1.deserializeWithMode; } });
+Object.defineProperty(exports, "serializeWithMode", { enumerable: true, get: function () { return serialization_1.serializeWithMode; } });

package/dist/stack/server/procedure.d.ts

@@ -1,18 +1,20 @@
-import type { GetOperation, InferMiddlewareOutput, InferSchemaInput, MiddlewareFunction, PostOperation, Prettify, ProcedureHandler, SchemaLike } from './types';
-type ProcedureOutputFormat = 'json';
-interface ProcedureBuilderState<TEnv> {
-    schema?: SchemaLike<any>;
-    middlewares: MiddlewareFunction<any, any, TEnv>[];
-    outputFormat: ProcedureOutputFormat;
-}
-export interface ProcedureBuilder<TCtx, TEnv, TInput = void> {
-    use<TMiddleware extends MiddlewareFunction<TCtx, any, TEnv>>(middleware: TMiddleware): ProcedureBuilder<Prettify<TCtx & InferMiddlewareOutput<TMiddleware>>, TEnv, TInput>;
-    input<TSchema extends SchemaLike<any>>(schema: TSchema): ProcedureBuilder<TCtx, TEnv, InferSchemaInput<TSchema>>;
-    query<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): GetOperation<TInput, TOutput, TCtx, TEnv>;
-    mutation<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): PostOperation<TInput, TOutput, TCtx, TEnv>;
-    get<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): GetOperation<TInput, TOutput, TCtx, TEnv>;
-    post<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): PostOperation<TInput, TOutput, TCtx, TEnv>;
-}
-export declare function createProcedureBuilder<TCtx = {}, TEnv = unknown, TInput = void>(state?: Partial<ProcedureBuilderState<TEnv>>): ProcedureBuilder<TCtx, TEnv, TInput>;
-export declare function isOperation(value: unknown): value is GetOperation | PostOperation;
-export {};
+import type { GetOperation, InferMiddlewareOutput, InferSchemaInput, MiddlewareFunction, PostOperation, Prettify, ProcedureHandler, SchemaLike } from './types';
+type ProcedureOutputFormat = 'json';
+interface ProcedureBuilderState<TEnv> {
+    schema?: SchemaLike<any>;
+    outputSchema?: SchemaLike<any>;
+    middlewares: MiddlewareFunction<any, any, TEnv>[];
+    outputFormat: ProcedureOutputFormat;
+}
+export interface ProcedureBuilder<TCtx, TEnv, TInput = void> {
+    use<TMiddleware extends MiddlewareFunction<TCtx, any, TEnv>>(middleware: TMiddleware): ProcedureBuilder<Prettify<TCtx & InferMiddlewareOutput<TMiddleware>>, TEnv, TInput>;
+    input<TSchema extends SchemaLike<any>>(schema: TSchema): ProcedureBuilder<TCtx, TEnv, InferSchemaInput<TSchema>>;
+    output<TSchema extends SchemaLike<any>>(schema: TSchema): ProcedureBuilder<TCtx, TEnv, TInput>;
+    query<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): GetOperation<TInput, TOutput, TCtx, TEnv>;
+    mutation<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): PostOperation<TInput, TOutput, TCtx, TEnv>;
+    get<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): GetOperation<TInput, TOutput, TCtx, TEnv>;
+    post<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): PostOperation<TInput, TOutput, TCtx, TEnv>;
+}
+export declare function createProcedureBuilder<TCtx = {}, TEnv = unknown, TInput = void>(state?: Partial<ProcedureBuilderState<TEnv>>): ProcedureBuilder<TCtx, TEnv, TInput>;
+export declare function isOperation(value: unknown): value is GetOperation | PostOperation;
+export {};