@teamblind/axeda-better-auth 0.0.0-stage → 0.1.0-alpha.1

package/dist/plugin.d.ts

@@ -0,0 +1,1987 @@
+import { type Axeda, type AxedaOptions, type AxedaPersistence, type Clock, type InvitationMessage } from '@teamblind/axeda-core';
+/** Cómo hacer llegar una invitación. Sin esto las invitaciones están desactivadas. */
+export interface InvitationDeliveryOptions {
+    /**
+     * El enlace de aceptación a partir del secreto. Lo construye la aplicación con su URL base
+     * configurada: nunca debe salir de la cabecera `Host` de una petición.
+     */
+    readonly acceptUrl: (token: string) => string;
+    /** Envía el correo. Recibe datos, no HTML: escapa lo que muestres. */
+    readonly send: (message: InvitationMessage & {
+        readonly link: string;
+    }) => Promise<void>;
+}
+export interface AxedaPluginOptions extends AxedaOptions {
+    /** Solo para pruebas. */
+    readonly clock?: Clock;
+    /** Cómo enviar las invitaciones. Sin esto están desactivadas. */
+    readonly invitationDelivery?: InvitationDeliveryOptions;
+    /**
+     * Publica `GET /axeda/public/identity` (nombre y logos de una compañía o negocio activo, sin
+     * sesión). Desactivado por defecto: es el único endpoint que no exige iniciar sesión.
+     */
+    readonly publicIdentity?: boolean;
+    /**
+     * La vida máxima de una sesión, en segundos, contada desde que se abrió. Better Auth renueva la
+     * sesión mientras se usa (`session.expiresIn` es el tiempo sin actividad), así que sin esto una
+     * sesión usada a diario no caducaría nunca. Pasado este tiempo hay que volver a iniciar sesión.
+     * Por defecto 30 días; `false` lo desactiva.
+     */
+    readonly maxSessionAge?: number | false;
+}
+/**
+ * Plugin de Axeda para Better Auth: esquema, endpoints `/axeda/*`, el hook de borrado de usuario
+ * y la conexión de la persistencia de Axeda al adaptador de base de datos de Better Auth.
+ *
+ * ```ts
+ * const axedaPlugin = axeda({ permissions: ['invoice:read'], roles: { viewer: ['invoice:read'] } });
+ * const auth = betterAuth({ plugins: [axedaPlugin] });
+ * await axedaPlugin.start(); // tras migrar la base de datos
+ * ```
+ */
+export declare function axeda(options: AxedaPluginOptions): {
+    id: "axeda";
+    schema: {
+        user: {
+            fields: {
+                authzVersion: {
+                    type: "number";
+                    required: false;
+                    defaultValue: number;
+                    input: false;
+                };
+                banned: {
+                    type: "boolean";
+                    required: false;
+                    defaultValue: false;
+                    input: false;
+                };
+                banReason: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                banExpires: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+            };
+        };
+        axedaRole: {
+            fields: {
+                key: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                name: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                description: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                permissions: {
+                    type: "string[]";
+                    required: true;
+                    input: false;
+                };
+                requireMfa: {
+                    type: "boolean";
+                    required: true;
+                    defaultValue: false;
+                    input: false;
+                };
+                status: {
+                    type: "string";
+                    required: true;
+                    defaultValue: string;
+                    input: false;
+                };
+                managed: {
+                    type: "boolean";
+                    required: true;
+                    defaultValue: false;
+                    input: false;
+                };
+                version: {
+                    type: "number";
+                    required: true;
+                    defaultValue: number;
+                    input: false;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+                updatedAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+            };
+            indexes: {
+                fields: [string];
+                unique: true;
+            }[];
+        };
+        axedaAssignment: {
+            fields: {
+                userId: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                    references: {
+                        model: string;
+                        field: string;
+                        onDelete: "cascade";
+                    };
+                };
+                roleId: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                    references: {
+                        model: "axedaRole";
+                        field: string;
+                        onDelete: "cascade";
+                    };
+                };
+                scopeType: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                scopeId: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                grantedBy: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+                expiresAt: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+            };
+            indexes: ({
+                fields: [string, string, string, string];
+                unique: true;
+            } | {
+                fields: [string, string];
+                unique?: never;
+            })[];
+        };
+        axedaState: {
+            fields: {
+                key: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                version: {
+                    type: "number";
+                    required: true;
+                    defaultValue: number;
+                    input: false;
+                };
+            };
+            indexes: {
+                fields: [string];
+                unique: true;
+            }[];
+        };
+        axedaAudit: {
+            fields: {
+                actorId: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                action: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                targetType: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                targetId: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                scopeType: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                scopeId: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                outcome: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                ip: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                userAgent: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                metadata: {
+                    type: "json";
+                    required: true;
+                    input: false;
+                };
+                at: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+            };
+            indexes: ({
+                fields: [string];
+            } | {
+                fields: [string, string];
+            })[];
+        };
+        axedaCompany: {
+            fields: {
+                slug: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                name: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                legalName: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                logoUrl: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                faviconUrl: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                status: {
+                    type: "string";
+                    required: true;
+                    defaultValue: string;
+                    input: false;
+                };
+                metadata: {
+                    type: "json";
+                    required: true;
+                    input: false;
+                };
+                version: {
+                    type: "number";
+                    required: true;
+                    defaultValue: number;
+                    input: false;
+                };
+                deletedAt: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+                updatedAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+            };
+            indexes: ({
+                fields: [string];
+                unique: true;
+            } | {
+                fields: [string];
+                unique?: never;
+            })[];
+        };
+        axedaBusiness: {
+            fields: {
+                companyId: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                    references: {
+                        model: "axedaCompany";
+                        field: string;
+                        onDelete: "cascade";
+                    };
+                };
+                slug: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                name: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                logoUrl: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                faviconUrl: {
+                    type: "string";
+                    required: false;
+                    input: false;
+                };
+                status: {
+                    type: "string";
+                    required: true;
+                    defaultValue: string;
+                    input: false;
+                };
+                metadata: {
+                    type: "json";
+                    required: true;
+                    input: false;
+                };
+                version: {
+                    type: "number";
+                    required: true;
+                    defaultValue: number;
+                    input: false;
+                };
+                deletedAt: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+                updatedAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+            };
+            indexes: ({
+                fields: [string, string];
+                unique: true;
+            } | {
+                fields: [string];
+                unique?: never;
+            })[];
+        };
+        axedaInvitation: {
+            fields: {
+                email: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                scopeType: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                scopeId: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                roleIds: {
+                    type: "string[]";
+                    required: true;
+                    input: false;
+                };
+                invitedBy: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                secretHash: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                expiresAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+                acceptedAt: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+                revokedAt: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+                pendingKey: {
+                    type: "string";
+                    required: true;
+                    input: false;
+                };
+                consumed: {
+                    type: "number";
+                    required: true;
+                    defaultValue: number;
+                    input: false;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                    input: false;
+                };
+            };
+            indexes: ({
+                fields: [string];
+                unique: true;
+            } | {
+                fields: [string, string];
+                unique?: never;
+            } | {
+                fields: [string];
+                unique?: never;
+            })[];
+        };
+    };
+    endpoints: {
+        axedaPublicIdentity: import("better-call").StrictEndpoint<"/axeda/public/identity", {
+            method: "GET";
+            query: import("zod").ZodObject<{
+                company: import("zod").ZodString;
+                business: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    public: boolean;
+                    requires: string;
+                    scope: "own";
+                };
+            };
+        }, import("@teamblind/axeda-core").PublicIdentity>;
+        axedaUserList: import("better-call").StrictEndpoint<"/axeda/user/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                emailPrefix: import("zod").ZodOptional<import("zod").ZodString>;
+                banned: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    true: "true";
+                    false: "false";
+                }>>;
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").ManagedUserDto[];
+            nextCursor: string | null;
+        }>;
+        axedaUserCreate: import("better-call").StrictEndpoint<"/axeda/user/create", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                email: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").ManagedUserDto>;
+        axedaUserBan: import("better-call").StrictEndpoint<"/axeda/user/ban", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                reason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODateTime>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").ManagedUserDto>;
+        axedaUserUnban: import("better-call").StrictEndpoint<"/axeda/user/unban", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").ManagedUserDto>;
+        axedaUserRevokeSessions: import("better-call").StrictEndpoint<"/axeda/user/revoke-sessions", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            revoked: number;
+        }>;
+        axedaMenu: import("better-call").StrictEndpoint<"/axeda/menu", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                locale: import("zod").ZodOptional<import("zod").ZodString>;
+                scopeType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    company: "company";
+                    business: "business";
+                    global: "global";
+                }>>;
+                scopeId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("@teamblind/axeda-core").MenuNode[];
+        }>;
+        axedaInvitationList: import("better-call").StrictEndpoint<"/axeda/invitation/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                pendingOnly: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    true: "true";
+                    false: "false";
+                }>>;
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                scopeType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    company: "company";
+                    business: "business";
+                    global: "global";
+                }>>;
+                scopeId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").InvitationDto[];
+            nextCursor: string | null;
+        }>;
+        axedaInvitationCreate: import("better-call").StrictEndpoint<"/axeda/invitation/create", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                email: import("zod").ZodString;
+                scope: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    type: import("zod").ZodLiteral<"global">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<{
+                        company: "company";
+                        business: "business";
+                    }>;
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>]>;
+                roleIds: import("zod").ZodArray<import("zod").ZodString>;
+                ttlHours: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").InvitationDto>;
+        axedaInvitationAccept: import("better-call").StrictEndpoint<"/axeda/invitation/accept", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                token: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            assignments: import("./dto.js").AssignmentDto[];
+        }>;
+        axedaInvitationRevoke: import("better-call").StrictEndpoint<"/axeda/invitation/revoke", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            revoked: true;
+        }>;
+        axedaCompanyList: import("better-call").StrictEndpoint<"/axeda/company/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                deleted: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    exclude: "exclude";
+                    include: "include";
+                    only: "only";
+                }>>;
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").CompanyDto[];
+            nextCursor: string | null;
+        }>;
+        axedaCompanyGet: import("better-call").StrictEndpoint<"/axeda/company/get", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").CompanyDto>;
+        axedaCompanyCreate: import("better-call").StrictEndpoint<"/axeda/company/create", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                slug: import("zod").ZodString;
+                name: import("zod").ZodString;
+                legalName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                logoUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                faviconUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").CompanyDto>;
+        axedaCompanyUpdate: import("better-call").StrictEndpoint<"/axeda/company/update", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                legalName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                logoUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                faviconUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").CompanyDto>;
+        axedaCompanySetStatus: import("better-call").StrictEndpoint<"/axeda/company/set-status", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                status: import("zod").ZodEnum<{
+                    active: "active";
+                    inactive: "inactive";
+                }>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").CompanyDto>;
+        axedaCompanyDelete: import("better-call").StrictEndpoint<"/axeda/company/delete", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                immediate: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            deleted: true;
+        }>;
+        axedaCompanyRestore: import("better-call").StrictEndpoint<"/axeda/company/restore", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").CompanyDto>;
+        axedaBusinessList: import("better-call").StrictEndpoint<"/axeda/business/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                companyId: import("zod").ZodString;
+                deleted: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    exclude: "exclude";
+                    include: "include";
+                    only: "only";
+                }>>;
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").BusinessDto[];
+            nextCursor: string | null;
+        }>;
+        axedaBusinessGet: import("better-call").StrictEndpoint<"/axeda/business/get", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").BusinessDto>;
+        axedaBusinessCreate: import("better-call").StrictEndpoint<"/axeda/business/create", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                companyId: import("zod").ZodString;
+                slug: import("zod").ZodString;
+                name: import("zod").ZodString;
+                logoUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                faviconUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").BusinessDto>;
+        axedaBusinessUpdate: import("better-call").StrictEndpoint<"/axeda/business/update", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                logoUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                faviconUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").BusinessDto>;
+        axedaBusinessSetStatus: import("better-call").StrictEndpoint<"/axeda/business/set-status", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                status: import("zod").ZodEnum<{
+                    active: "active";
+                    inactive: "inactive";
+                }>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").BusinessDto>;
+        axedaBusinessDelete: import("better-call").StrictEndpoint<"/axeda/business/delete", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                immediate: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            deleted: true;
+        }>;
+        axedaBusinessRestore: import("better-call").StrictEndpoint<"/axeda/business/restore", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").BusinessDto>;
+        axedaMe: import("better-call").StrictEndpoint<"/axeda/me", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            userId: string;
+            twoFactorEnabled: boolean;
+            globalPermissions: string[];
+            assignments: import("./dto.js").AssignmentDto[];
+        }>;
+        axedaPermissionList: import("better-call").StrictEndpoint<"/axeda/permission/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            permissions: string[];
+        }>;
+        axedaRoleList: import("better-call").StrictEndpoint<"/axeda/role/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").RoleDto[];
+            nextCursor: string | null;
+        }>;
+        axedaRoleGet: import("better-call").StrictEndpoint<"/axeda/role/get", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").RoleDto>;
+        axedaRoleCreate: import("better-call").StrictEndpoint<"/axeda/role/create", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                key: import("zod").ZodString;
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                permissions: import("zod").ZodArray<import("zod").ZodString>;
+                requireMfa: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").RoleDto>;
+        axedaRoleUpdate: import("better-call").StrictEndpoint<"/axeda/role/update", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                description: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                permissions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                requireMfa: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").RoleDto>;
+        axedaRoleSetStatus: import("better-call").StrictEndpoint<"/axeda/role/set-status", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                version: import("zod").ZodNumber;
+                status: import("zod").ZodEnum<{
+                    active: "active";
+                    inactive: "inactive";
+                }>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").RoleDto>;
+        axedaRoleDelete: import("better-call").StrictEndpoint<"/axeda/role/delete", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            deleted: true;
+        }>;
+        axedaAssignmentList: import("better-call").StrictEndpoint<"/axeda/assignment/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                scopeType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    company: "company";
+                    business: "business";
+                    global: "global";
+                }>>;
+                scopeId: import("zod").ZodOptional<import("zod").ZodString>;
+                userId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").AssignmentDto[];
+            nextCursor: string | null;
+        }>;
+        axedaAssignmentCreate: import("better-call").StrictEndpoint<"/axeda/assignment/create", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                userId: import("zod").ZodString;
+                roleId: import("zod").ZodString;
+                scope: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    type: import("zod").ZodLiteral<"global">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<{
+                        company: "company";
+                        business: "business";
+                    }>;
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>]>;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODateTime>>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, import("./dto.js").AssignmentDto>;
+        axedaAssignmentRevoke: import("better-call").StrictEndpoint<"/axeda/assignment/revoke", {
+            method: "POST";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            body: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            revoked: true;
+        }>;
+        axedaAuditList: import("better-call").StrictEndpoint<"/axeda/audit/list", {
+            method: "GET";
+            use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>>[];
+            query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                scopeType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    company: "company";
+                    business: "business";
+                    global: "global";
+                }>>;
+                scopeId: import("zod").ZodOptional<import("zod").ZodString>;
+                actorId: import("zod").ZodOptional<import("zod").ZodString>;
+                action: import("zod").ZodOptional<import("zod").ZodString>;
+                targetType: import("zod").ZodOptional<import("zod").ZodString>;
+                targetId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            metadata: {
+                axeda: {
+                    requires: string;
+                    scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+                };
+            };
+        }, {
+            items: import("./dto.js").AuditEventDto[];
+            nextCursor: string | null;
+        }>;
+    };
+    rateLimit: {
+        pathMatcher: (path: string) => boolean;
+        max: number;
+        window: number;
+    }[];
+    hooks: {
+        after: {
+            matcher: (context: import("@better-auth/core").HookEndpointContext) => boolean;
+            handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>>;
+        }[];
+    };
+    init(ctx: import("@better-auth/core").AuthContext): {
+        options: {
+            databaseHooks: {
+                session: {
+                    create: {
+                        before: (session: {
+                            userId: string;
+                        }) => Promise<{
+                            data: {
+                                expiresAt: Date;
+                            };
+                        } | undefined>;
+                    };
+                    update: {
+                        before: (session: {
+                            expiresAt?: unknown;
+                        }, context: unknown) => Promise<{
+                            data: {
+                                expiresAt: Date;
+                            };
+                        } | undefined>;
+                    };
+                };
+                user: {
+                    delete: {
+                        after: (user: {
+                            id: string;
+                        }) => Promise<void>;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    /** El núcleo de Axeda (`can`, `scopesFor`, `bootstrap`…). Disponible tras crear Better Auth. */
+    instance: () => Axeda;
+    /** Comprueba la base de datos y sincroniza las funciones declaradas. Llamar tras migrar. */
+    start: () => Promise<void>;
+    /** La persistencia, para herramientas de la propia aplicación. */
+    persistence: () => AxedaPersistence;
+};
+export type AxedaPlugin = ReturnType<typeof axeda>;