@m5kdev/backend 0.4.0 → 0.6.0

package/dist/src/modules/ai/ai.prompts.d.ts

@@ -0,0 +1,5 @@
+import { Prompt } from "./ai.prompt";
+export declare const repairJsonPrompt: Prompt<{
+    text: string;
+    error: string;
+}>;

package/dist/src/modules/ai/ai.prompts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repairJsonPrompt = void 0;
+const ai_prompt_1 = require("./ai.prompt");
+exports.repairJsonPrompt = new ai_prompt_1.Prompt(`
+You are a JSON repair expert. You are given a JSON string that is invalid, error message and a schema that is used to parse the JSON string. You need to repair the JSON string and return the repaired JSON adher to the schema.
+
+## Text
+
+{{text}}
+
+## Error
+
+{{error}}
+
+`);

package/dist/src/modules/ai/ai.service.d.ts

@@ -3,10 +3,10 @@ import type { Mastra } from "@mastra/core";
 import type { FullOutput, MastraModelOutput } from "@mastra/core/stream";
 import { MDocument } from "@mastra/rag";
 import type { OpenRouterProvider } from "@openrouter/ai-sdk-provider";
-import { generateObject, generateText } from "ai";
+import { generateText, type ModelMessage } from "ai";
 import type Replicate from "replicate";
 import type { ZodType, z } from "zod";
-import type { User } from "../auth/auth.lib";
+import type { Context, User } from "../auth/auth.lib";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
 import type { AiUsageRepository, AiUsageRow } from "./ai.repository";
@@ -18,6 +18,26 @@ type MessageListInput = {
     role: "user" | "assistant" | "system";
     content: string;
 }[];
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type GenerateTextInput = {
+    prompt: string | ModelMessage[];
+    messages?: never;
+} | {
+    messages: ModelMessage[];
+    prompt?: never;
+};
+type AIServiceGenerateTextParams = Omit<GenerateTextParams, "model" | "prompt" | "messages"> & GenerateTextInput & {
+    model: string;
+    removeMDash?: boolean;
+    ctx?: Context;
+};
+type AIServiceGenerateObjectParams<T extends ZodType> = Omit<GenerateTextParams, "model" | "prompt" | "messages" | "output"> & GenerateTextInput & {
+    model: string;
+    schema: T;
+    repairAttempts?: number;
+    repairModel?: string;
+    ctx?: Context;
+};
 export declare class AIService<MastraInstance extends Mastra> extends BaseService<{
     aiUsage?: AiUsageRepository;
 }, {
@@ -39,8 +59,8 @@ export declare class AIService<MastraInstance extends Mastra> extends BaseServic
         replicate?: Replicate;
     });
     getMastra(): MastraInstance;
-    prepareModel(model: string): any;
-    prepareEmbeddingModel(model: string): any;
+    prepareModel(model: string): ReturnType<OpenRouterProvider["chat"]>;
+    prepareEmbeddingModel(model: string): ReturnType<OpenRouterProvider["textEmbeddingModel"]>;
     agentUse(agent: string, options: MastraAgentGenerateOptions & {
         prompt?: string;
         messages?: MessageListInput;
@@ -94,14 +114,8 @@ export declare class AIService<MastraInstance extends Mastra> extends BaseServic
     }[], model?: string): ServerResultAsync<{
         embeddings: number[][];
     }>;
-    generateText(params: Omit<Parameters<typeof generateText>[0], "model"> & {
-        model: string;
-        removeMDash?: boolean;
-    }): ServerResultAsync<string>;
-    generateObject<T extends ZodType>(params: Omit<Parameters<typeof generateObject<T>>[0], "model" | "schema"> & {
-        model: string;
-        schema: T;
-    }): ServerResultAsync<z.infer<T>>;
+    generateText(params: AIServiceGenerateTextParams): ServerResultAsync<string>;
+    generateObject<T extends ZodType>(params: AIServiceGenerateObjectParams<T>): ServerResultAsync<z.infer<T>>;
     generateReplicate(model: Parameters<Replicate["run"]>[0], options: Parameters<Replicate["run"]>[1]): ServerResultAsync<object>;
     generateTranscript(file_url: string): ServerResultAsync<{
         text: string;

package/dist/src/modules/ai/ai.service.js

@@ -6,8 +6,10 @@ const ai_utils_1 = require("@m5kdev/commons/modules/ai/ai.utils");
 const request_context_1 = require("@mastra/core/request-context");
 const rag_1 = require("@mastra/rag");
 const ai_1 = require("ai");
+const jsonrepair_1 = require("jsonrepair");
 const neverthrow_1 = require("neverthrow");
 const base_service_1 = require("../base/base.service");
+const ai_prompts_1 = require("./ai.prompts");
 class AIService extends base_service_1.BaseService {
     helpers = {
         arrayToPseudoXML: ai_utils_1.arrayToPseudoXML,
@@ -31,15 +33,19 @@ class AIService extends base_service_1.BaseService {
         if (!this.openrouter) {
             throw new Error("OpenRouter is not configured");
         }
-        const openrouterModel = this.openrouter.chat(model);
-        return openrouterModel;
+        return this.openrouter.chat(model, {
+            usage: {
+                include: true,
+            },
+        });
     }
     prepareEmbeddingModel(model) {
         if (!this.openrouter) {
             throw new Error("OpenRouter is not configured");
         }
-        const openrouterModel = this.openrouter.textEmbeddingModel(model);
-        return openrouterModel;
+        const openrouter = this.openrouter;
+        return (openrouter.embeddingModel?.(model) ??
+            openrouter.textEmbeddingModel(model));
     }
     async agentUse(agent, options, ctx) {
         return this.throwableAsync(async () => {
@@ -146,21 +152,105 @@ class AIService extends base_service_1.BaseService {
     }
     async generateText(params) {
         return this.throwableAsync(async () => {
-            const { removeMDash = true, model, ...rest } = params;
-            const result = await (0, ai_1.generateText)({ ...rest, model: this.prepareModel(model) });
+            const { removeMDash = true, model, prompt, messages, ctx, ...rest } = params;
+            const request = messages
+                ? { ...rest, model: this.prepareModel(model), messages }
+                : { ...rest, model: this.prepareModel(model), prompt };
+            const result = await (0, ai_1.generateText)(request);
+            if (this.repository.aiUsage) {
+                const createUsageResult = await this.repository.aiUsage.create({
+                    userId: ctx?.user?.id,
+                    model,
+                    provider: "openrouter",
+                    feature: "generateText",
+                    traceId: result.providerMetadata?.openrouter?.traceId?.toString(),
+                    inputTokens: result.usage.inputTokens,
+                    outputTokens: result.usage.outputTokens,
+                    totalTokens: result.usage.totalTokens,
+                    cost: result?.providerMetadata?.openrouter?.usage?.cost ?? 0,
+                });
+                if (createUsageResult.isErr())
+                    return (0, neverthrow_1.err)(createUsageResult.error);
+            }
             return (0, neverthrow_1.ok)(removeMDash ? result.text.replace(/\u2013|\u2014/g, "-") : result.text);
         });
     }
     async generateObject(params) {
-        return this.throwableAsync(async () => {
-            const model = this.prepareModel(params.model);
-            const result = await (0, ai_1.generateObject)({
-                ...params,
-                model,
-                schema: params.schema,
-            });
-            return (0, neverthrow_1.ok)(result.object);
-        });
+        const { model, schema, prompt, messages, repairAttempts = 0, repairModel, ctx, ...rest } = params;
+        const request = messages
+            ? {
+                ...rest,
+                model: this.prepareModel(model),
+                messages,
+                output: ai_1.Output.object({ schema }),
+            }
+            : {
+                ...rest,
+                model: this.prepareModel(model),
+                prompt,
+                output: ai_1.Output.object({ schema }),
+            };
+        try {
+            const result = await (0, ai_1.generateText)(request);
+            if (this.repository.aiUsage) {
+                const createUsageResult = await this.repository.aiUsage.create({
+                    userId: ctx?.user?.id,
+                    model,
+                    provider: "openrouter",
+                    feature: "generateObject",
+                    traceId: result.providerMetadata?.openrouter?.traceId?.toString(),
+                    inputTokens: result.usage.inputTokens,
+                    outputTokens: result.usage.outputTokens,
+                    totalTokens: result.usage.totalTokens,
+                    cost: result?.providerMetadata?.openrouter?.usage?.cost ?? 0,
+                });
+                if (createUsageResult.isErr())
+                    return (0, neverthrow_1.err)(createUsageResult.error);
+            }
+            return (0, neverthrow_1.ok)(result.output);
+        }
+        catch (error) {
+            if (ai_1.NoObjectGeneratedError.isInstance(error)) {
+                if (this.repository.aiUsage) {
+                    const createUsageResult = await this.repository.aiUsage.create({
+                        userId: ctx?.user?.id,
+                        model,
+                        provider: "openrouter",
+                        feature: "generateObject",
+                        traceId: null,
+                        inputTokens: error?.usage?.inputTokens,
+                        outputTokens: error?.usage?.outputTokens,
+                        totalTokens: error?.usage?.totalTokens,
+                        cost: 0,
+                    });
+                    if (createUsageResult.isErr())
+                        return (0, neverthrow_1.err)(createUsageResult.error);
+                }
+                if (error.text) {
+                    const repairedText = (0, jsonrepair_1.jsonrepair)(error.text);
+                    const parsed = schema.safeParse(repairedText);
+                    if (parsed.success)
+                        return (0, neverthrow_1.ok)(parsed.data);
+                    if (repairAttempts === 0)
+                        return this.error("PARSE_ERROR", "AI: Agent object failed", { cause: error });
+                    return this.generateObject({
+                        ...rest,
+                        prompt: ai_prompts_1.repairJsonPrompt.compile({
+                            text: error.text,
+                            error: JSON.stringify(error.cause ?? "Unknown error"),
+                        }),
+                        repairAttempts: repairAttempts - 1,
+                        model: repairModel ?? model,
+                        schema,
+                        ctx,
+                    });
+                }
+                return this.error("PARSE_ERROR", "AI: Agent object failed without text", {
+                    cause: error,
+                });
+            }
+            return this.error("BAD_REQUEST", "AI: Provided failed to generate object", { cause: error });
+        }
     }
     async generateReplicate(model, options) {
         return this.throwableAsync(async () => {

package/dist/src/modules/auth/auth.dto.d.ts

@@ -10,9 +10,9 @@ export declare const waitlistSchema: z.ZodObject<{
     expiresAt: z.ZodNullable<z.ZodDate>;
 }, z.core.$strip>;
 export declare const waitlistOutputSchema: z.ZodObject<{
-    name: z.ZodNullable<z.ZodString>;
     id: z.ZodString;
     email: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
     status: z.ZodString;
     createdAt: z.ZodDate;
     updatedAt: z.ZodNullable<z.ZodDate>;
@@ -53,9 +53,9 @@ export declare const accountClaimMagicLinkSchema: z.ZodObject<{
     createdAt: z.ZodDate;
 }, z.core.$strip>;
 export declare const accountClaimMagicLinkOutputSchema: z.ZodObject<{
-    url: z.ZodString;
     id: z.ZodString;
     email: z.ZodString;
+    url: z.ZodString;
     createdAt: z.ZodDate;
     userId: z.ZodString;
     expiresAt: z.ZodNullable<z.ZodDate>;

package/dist/src/modules/auth/auth.lib.d.ts

@@ -3260,13 +3260,13 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
                     $Infer: {
                         body: ({
                             permission: {
-                                readonly user?: ("get" | "delete" | "list" | "create" | "update" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly user?: ("get" | "set-role" | "create" | "update" | "delete" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
                                 readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                             };
                             permissions?: never | undefined;
                         } | {
                             permissions: {
-                                readonly user?: ("get" | "delete" | "list" | "create" | "update" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly user?: ("get" | "set-role" | "create" | "update" | "delete" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
                                 readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                             };
                             permission?: never | undefined;
@@ -4811,7 +4811,7 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
     } | undefined;
     verification?: {
         modelName?: string;
-        fields?: Partial<Record<"value" | "createdAt" | "updatedAt" | "expiresAt" | "identifier", string>>;
+        fields?: Partial<Record<"createdAt" | "updatedAt" | "expiresAt" | "value" | "identifier", string>>;
         additionalFields?: {
             [key: string]: import("better-auth", { with: { "resolution-mode": "import" } }).DBFieldAttribute;
         };

package/dist/src/modules/auth/auth.repository.d.ts

@@ -1,8 +1,8 @@
 import type { LibSQLDatabase } from "drizzle-orm/libsql";
-import * as auth from "./auth.db";
-import type { AccountClaim, AccountClaimMagicLink, AccountClaimMagicLinkOutput, AccountClaimOutput, Waitlist, WaitlistOutput } from "./auth.dto";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseRepository } from "../base/base.repository";
+import * as auth from "./auth.db";
+import type { AccountClaim, AccountClaimMagicLink, AccountClaimMagicLinkOutput, AccountClaimOutput, Waitlist, WaitlistOutput } from "./auth.dto";
 declare const schema: {
     users: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "users";

package/dist/src/modules/auth/auth.repository.js

@@ -5,8 +5,8 @@ const tslib_1 = require("tslib");
 const drizzle_orm_1 = require("drizzle-orm");
 const neverthrow_1 = require("neverthrow");
 const uuid_1 = require("uuid");
-const auth = tslib_1.__importStar(require("./auth.db"));
 const base_repository_1 = require("../base/base.repository");
+const auth = tslib_1.__importStar(require("./auth.db"));
 const schema = { ...auth };
 function parseOrganizationMetadata(metadata) {
     if (!metadata)

package/dist/src/modules/auth/auth.service.d.ts

@@ -1,10 +1,10 @@
-import type { AccountClaim, AccountClaimMagicLinkOutput, AccountClaimOutput, Waitlist, WaitlistOutput } from "./auth.dto";
-import type { Context, User } from "./auth.lib";
-import type { AuthRepository } from "./auth.repository";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
 import type { BillingService } from "../billing/billing.service";
 import type { EmailService } from "../email/email.service";
+import type { AccountClaim, AccountClaimMagicLinkOutput, AccountClaimOutput, Waitlist, WaitlistOutput } from "./auth.dto";
+import type { Context, User } from "./auth.lib";
+import type { AuthRepository } from "./auth.repository";
 type AuthServiceDependencies = {
     email: EmailService;
 } | {

package/dist/src/modules/auth/auth.service.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthService = void 0;
 const neverthrow_1 = require("neverthrow");
-const base_service_1 = require("../base/base.service");
 const posthog_1 = require("../../utils/posthog");
+const base_service_1 = require("../base/base.service");
 class AuthService extends base_service_1.BaseService {
     getBillingService() {
         if (!("billing" in this.service))

package/dist/src/modules/auth/auth.trpc.d.ts

@@ -1,5 +1,5 @@
-import type { AuthService } from "./auth.service";
 import { type TRPCMethods } from "../../utils/trpc";
+import type { AuthService } from "./auth.service";
 export declare function createAuthTRPC({ router, publicProcedure, privateProcedure: procedure, adminProcedure }: TRPCMethods, authService: AuthService): import("@trpc/server").TRPCBuiltRouter<{
     ctx: import("./auth.lib").Context;
     meta: any;
@@ -138,8 +138,8 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
     listAdminWaitlist: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {
-            name: string | null;
             id: string;
+            name: string | null;
             email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
@@ -152,8 +152,8 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
             email: string;
         };
         output: {
-            name: string | null;
             id: string;
+            name: string | null;
             email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
@@ -183,8 +183,8 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
             id: string;
         };
         output: {
-            name: string | null;
             id: string;
+            name: string | null;
             email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
@@ -197,8 +197,8 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
             id: string;
         };
         output: {
-            name: string | null;
             id: string;
+            name: string | null;
             email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
@@ -211,8 +211,8 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
             email: string;
         };
         output: {
-            name: string | null;
             id: string;
+            name: string | null;
             email: string | null;
             createdAt: Date;
             updatedAt: Date | null;

package/dist/src/modules/auth/auth.trpc.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAuthTRPC = createAuthTRPC;
 const zod_1 = require("zod");
-const auth_dto_1 = require("./auth.dto");
 const trpc_1 = require("../../utils/trpc");
+const auth_dto_1 = require("./auth.dto");
 function createAuthTRPC({ router, publicProcedure, privateProcedure: procedure, adminProcedure }, authService) {
     return router({
         getUserWaitlistCount: procedure.output(zod_1.z.number()).query(async ({ ctx }) => {

package/dist/src/modules/base/base.abstract.d.ts

@@ -1,8 +1,8 @@
 import type { TRPC_ERROR_CODE_KEY } from "@trpc/server";
-import type { ServerResult, ServerResultAsync } from "./base.dto";
-import type { ServerErrorLayer } from "./base.types";
 import { ServerError } from "../../utils/errors";
 import { logger } from "../../utils/logger";
+import type { ServerResult, ServerResultAsync } from "./base.dto";
+import type { ServerErrorLayer } from "./base.types";
 export declare abstract class Base {
     layer: ServerErrorLayer;
     logger: ReturnType<typeof logger.child>;
@@ -15,4 +15,5 @@ export declare abstract class Base {
     handleUnknownError(error: unknown): ServerError;
     throwable<T>(fn: () => ServerResult<T>): ServerResult<T>;
     throwableAsync<T>(fn: () => ServerResultAsync<T>): ServerResultAsync<T>;
+    throwablePromise<T>(fn: () => Promise<T>, errorHandler?: (error: unknown) => ServerError): ServerResultAsync<T>;
 }

package/dist/src/modules/base/base.abstract.js

@@ -43,11 +43,20 @@ class Base {
     }
     async throwableAsync(fn) {
         try {
-            return fn();
+            return await fn();
         }
         catch (error) {
             return (0, neverthrow_1.err)(this.handleUnknownError(error));
         }
     }
+    async throwablePromise(fn, errorHandler) {
+        try {
+            const result = await fn();
+            return (0, neverthrow_1.ok)(result);
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(errorHandler ? errorHandler(error) : this.handleUnknownError(error));
+        }
+    }
 }
 exports.Base = Base;

package/dist/src/modules/base/base.procedure.d.ts

@@ -0,0 +1,112 @@
+import type { QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+import type { TRPC_ERROR_CODE_KEY } from "@trpc/server";
+import type { ServerError } from "../../utils/errors";
+import type { logger } from "../../utils/logger";
+import type { Context, Session, User } from "../auth/auth.lib";
+import type { Base } from "./base.abstract";
+import type { ServerResult, ServerResultAsync } from "./base.dto";
+import type { Entity, ResourceActionGrant } from "./base.grants";
+type ServiceLogger = ReturnType<typeof logger.child>;
+type RepositoryMap = Record<string, Base>;
+type ServiceMap = Record<string, Base>;
+export type ServiceProcedureContext = {
+    user?: User | null;
+    session?: Session | null;
+} & Record<string, unknown>;
+export type ServiceProcedureState = Record<string, unknown>;
+export type ServiceProcedureStoredValue<T> = [T] extends [undefined] ? undefined : Awaited<T>;
+export type ServiceProcedureResultLike<T> = T | ServerResult<T> | Promise<T | ServerResult<T>>;
+export type ServiceProcedureContextFilterScope = "user" | "organization" | "team";
+export type ServiceProcedureContextFilteredInput<TInput> = Extract<NonNullable<TInput>, QueryInput>;
+export type ServiceProcedure<TInput, TCtx extends ServiceProcedureContext, TOutput> = (input: TInput, ctx: TCtx) => ServerResultAsync<TOutput>;
+export type ServiceProcedureArgs<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState> = {
+    input: TInput;
+    ctx: TCtx;
+    state: State;
+    repository: Repositories;
+    service: Services;
+    logger: ServiceLogger;
+};
+export type ServiceProcedureStep<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TOutput = undefined> = (args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<ServiceProcedureStoredValue<TOutput>>;
+export type ServiceProcedureInputMapper<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TNextInput> = (args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<ServiceProcedureStoredValue<TNextInput>>;
+export type ServiceProcedureHandler<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TOutput> = (args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<TOutput>;
+export type ServiceProcedureEntityResolver<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TEntities extends Entity | Entity[] | undefined> = TEntities | ((args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<TEntities>);
+type ServiceProcedureAccessBaseConfig = {
+    action: string;
+    grants?: ResourceActionGrant[];
+};
+export type ServiceProcedureEntityStepName<State extends ServiceProcedureState> = Extract<{
+    [Key in keyof State]: State[Key] extends Entity | Entity[] | undefined ? Key : never;
+}[keyof State], string>;
+export type ServiceProcedureAccessEntitiesConfig<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TEntities extends Entity | Entity[] | undefined = undefined> = ServiceProcedureAccessBaseConfig & {
+    entities?: ServiceProcedureEntityResolver<TInput, TCtx, Repositories, Services, State, TEntities>;
+    entityStep?: never;
+};
+export type ServiceProcedureAccessStateConfig<State extends ServiceProcedureState, StepName extends ServiceProcedureEntityStepName<State>> = ServiceProcedureAccessBaseConfig & {
+    entityStep: StepName;
+    entities?: never;
+};
+export type ServiceProcedureAccessConfig<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TEntities extends Entity | Entity[] | undefined = undefined> = ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State, TEntities> | ServiceProcedureAccessStateConfig<State, ServiceProcedureEntityStepName<State>>;
+export interface ServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>> {
+    use<StepName extends string, TOutput = void>(stepName: StepName, step: ServiceProcedureStep<TInput, TCtx, Repositories, Services, State, TOutput>): ServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TOutput>>>;
+    mapInput<StepName extends string, TNextInput>(stepName: StepName, step: ServiceProcedureInputMapper<TInput, TCtx, Repositories, Services, State, TNextInput>): ServiceProcedureBuilder<ServiceProcedureStoredValue<TNextInput>, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TNextInput>>>;
+    addContextFilter(include?: readonly ServiceProcedureContextFilterScope[]): ServiceProcedureBuilder<ServiceProcedureContextFilteredInput<TInput>, TCtx & Context, Repositories, Services, State & {
+        contextFilter: ServiceProcedureContextFilteredInput<TInput>;
+    }>;
+    requireAuth(): ServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State>;
+    handle<TOutput>(handler: ServiceProcedureHandler<TInput, TCtx, Repositories, Services, State, TOutput>): ServiceProcedure<TInput, TCtx, TOutput>;
+}
+export interface PermissionServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>> extends ServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State> {
+    use<StepName extends string, TOutput = void>(stepName: StepName, step: ServiceProcedureStep<TInput, TCtx, Repositories, Services, State, TOutput>): PermissionServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TOutput>>>;
+    mapInput<StepName extends string, TNextInput>(stepName: StepName, step: ServiceProcedureInputMapper<TInput, TCtx, Repositories, Services, State, TNextInput>): PermissionServiceProcedureBuilder<ServiceProcedureStoredValue<TNextInput>, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TNextInput>>>;
+    addContextFilter(include?: readonly ServiceProcedureContextFilterScope[]): PermissionServiceProcedureBuilder<ServiceProcedureContextFilteredInput<TInput>, TCtx & Context, Repositories, Services, State & {
+        contextFilter: ServiceProcedureContextFilteredInput<TInput>;
+    }>;
+    requireAuth(): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State>;
+    access(config: ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State>): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State>;
+    access<TEntities extends Entity | Entity[] | undefined>(config: ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State, TEntities>): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State & {
+        access: TEntities;
+    }>;
+    access<StepName extends ServiceProcedureEntityStepName<State>>(config: ServiceProcedureAccessStateConfig<State, StepName>): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State & {
+        access: State[StepName];
+    }>;
+}
+type BaseServiceProcedureHost<Repositories extends RepositoryMap, Services extends ServiceMap> = {
+    repository: Repositories;
+    service: Services;
+    logger: ServiceLogger;
+    addContextFilter(ctx: Context, include?: {
+        user?: boolean;
+        organization?: boolean;
+        team?: boolean;
+    }, query?: QueryInput): QueryInput;
+    error(code: TRPC_ERROR_CODE_KEY, message?: string, options?: {
+        cause?: unknown;
+        clientMessage?: string;
+        log?: boolean;
+    }): ServerResult<never>;
+    throwableAsync<T>(fn: () => ServerResultAsync<T>): ServerResultAsync<T>;
+    handleUnknownError(error: unknown): ServerError;
+};
+type PermissionServiceProcedureHost<Repositories extends RepositoryMap, Services extends ServiceMap> = BaseServiceProcedureHost<Repositories, Services> & {
+    checkPermission<T extends Entity>(ctx: {
+        session: Session;
+        user: User;
+    }, action: string, entities?: T | T[], grants?: ResourceActionGrant[]): boolean;
+    checkPermissionAsync<T extends Entity>(ctx: {
+        session: Session;
+        user: User;
+    }, action: string, getEntities: () => ServerResultAsync<T | T[] | undefined>, grants?: ResourceActionGrant[]): ServerResultAsync<boolean>;
+};
+type ProcedureRuntimeStep<Repositories extends RepositoryMap, Services extends ServiceMap> = {
+    stage: "use" | "input" | "auth" | "access";
+    stepName: string;
+    run: (args: ServiceProcedureArgs<unknown, ServiceProcedureContext, Repositories, Services, ServiceProcedureState>) => Promise<ServerResult<unknown>>;
+};
+type ProcedureBuilderConfig<Repositories extends RepositoryMap, Services extends ServiceMap> = {
+    name: string;
+    steps: ProcedureRuntimeStep<Repositories, Services>[];
+};
+export declare function createServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>>(host: BaseServiceProcedureHost<Repositories, Services>, config: ProcedureBuilderConfig<Repositories, Services>): ServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State>;
+export declare function createPermissionServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>>(host: PermissionServiceProcedureHost<Repositories, Services>, config: ProcedureBuilderConfig<Repositories, Services>): PermissionServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State>;
+export {};