import { z } from 'zod';
import { InferSelectModel, InferInsertModel } from 'drizzle-orm';
import { s as schema } from './rbac.P-yL2vdQ.cjs';

declare const tables: typeof schema;

interface RoleScopeSelectType extends InferSelectModel<typeof tables.roleScope> {
}
interface RoleScopeInsertType extends InferInsertModel<typeof tables.roleScope> {
}

interface RoleSelectType extends InferSelectModel<typeof tables.role> {
}
interface RoleInsertType extends InferInsertModel<typeof tables.role> {
}

type Scope = string;
type LabeledScope = {
    label: string;
    value: Scope;
};

interface UserRoleSelectType extends InferSelectModel<typeof tables.userRole> {
}
interface UserRoleInsertType extends InferInsertModel<typeof tables.userRole> {
}

interface UserScopeSelectType extends InferSelectModel<typeof tables.userScope> {
}
interface UserScopeInsertType extends InferInsertModel<typeof tables.userScope> {
}

declare const assignRoleToUserInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    roleId: z.ZodUUID;
}, z.core.$strip>;
interface AssignRoleToUserInput extends z.infer<typeof assignRoleToUserInputSchema> {
}
interface AssignRoleToUserOutput extends UserRoleSelectType {
}

declare const assignRolesToUserInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    roles: z.ZodArray<z.ZodUUID>;
}, z.core.$strip>;
interface AssignRolesToUserInput extends z.infer<typeof assignRolesToUserInputSchema> {
}
interface AssignRolesToUserOutput extends UserRoleSelectType {
}

declare const createRoleInputSchema: z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>;
interface CreateRoleInput extends z.infer<typeof createRoleInputSchema> {
}
interface CreateRoleOutput extends RoleSelectType {
}

declare const deleteRoleInputSchema: z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>;
interface DeleteRoleInput extends z.infer<typeof deleteRoleInputSchema> {
}
interface DeleteRoleOutput {
}

interface GetAllUserRolesOutput {
    userRoles: {
        userId: string;
        roleId: string | null;
        roleName: string | null;
    }[];
    count: number;
}

interface GetPermissionsOutput {
    roles: {
        id: string;
        name: string;
        numberOfScopes: number;
        numberOfUsers: number;
    }[];
    rolesCount: number;
    scopes: {
        scope: Scope;
        label: string | null;
    }[];
    scopesCount: number;
    roleScopes: {
        roleId: string;
        roleName: string;
        scopes: {
            id: string;
            scope: Scope;
            label: string | null;
            resourceId: string | null;
        }[];
    }[];
    labeledScopes: LabeledScope[];
    roleScopesCount: number;
}

declare const getUserPermissionsInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    filter: z.ZodOptional<z.ZodObject<{
        scopeContains: z.ZodOptional<z.ZodString>;
        scopeStartsWith: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
interface GetUserPermissionsInput extends z.infer<typeof getUserPermissionsInputSchema> {
}
interface GetUserPermissionsOutput {
    roles: {
        id: string;
        name: string;
    }[];
    rolesCount: number;
    roleScopes: {
        id: string;
        scope: Scope;
        label: string | null;
        resourceId: string | null;
    }[];
    roleScopesCount: number;
    scopes: {
        id: string;
        scope: Scope;
        label: string | null;
        resourceId: string | null;
    }[];
    scopesCount: number;
}

declare const grantScopeToRoleInputSchema: z.ZodObject<{
    roleId: z.ZodUUID;
    scope: z.ZodString;
    resourceId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
interface GrantScopeToRoleInput extends z.infer<typeof grantScopeToRoleInputSchema> {
}
interface GrantScopeToRoleOutput extends RoleScopeSelectType {
}

declare const grantScopeToUserInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    scope: z.ZodString;
    resourceId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
interface GrantScopeToUserInput extends z.infer<typeof grantScopeToUserInputSchema> {
}
interface GrantScopeToUserOutput extends UserScopeSelectType {
}

declare const grantScopesToUserInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    scopes: z.ZodArray<z.ZodObject<{
        scope: z.ZodString;
        resourceId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
interface GrantScopesToUserInput extends z.infer<typeof grantScopesToUserInputSchema> {
}
interface GrantScopesToUserOutput extends UserScopeSelectType {
}

declare const revokeRoleFromUserInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    roleId: z.ZodUUID;
}, z.core.$strip>;
interface RevokeRoleFromUserInput extends z.infer<typeof revokeRoleFromUserInputSchema> {
}
interface RevokeRoleFromUserOutput {
}

declare const revokeScopeFromRoleInputSchema: z.ZodObject<{
    roleId: z.ZodUUID;
    scope: z.ZodString;
    resourceId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
interface RevokeScopeFromRoleInput extends z.infer<typeof revokeScopeFromRoleInputSchema> {
}
interface RevokeScopeFromRoleOutput {
}

declare const revokeScopeFromUserInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    scope: z.ZodString;
    resourceId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
interface RevokeScopeFromUserInput extends z.infer<typeof revokeScopeFromUserInputSchema> {
}
interface RevokeScopeFromUserOutput {
}

declare const updateRoleInputSchema: z.ZodObject<{
    id: z.ZodUUID;
    name: z.ZodString;
}, z.core.$strip>;
interface UpdateRoleInput extends z.infer<typeof updateRoleInputSchema> {
}
interface UpdateRoleOutput {
}

declare const scopeObjectSchema: z.ZodObject<{
    scope: z.ZodString;
    resourceId: z.ZodOptional<z.ZodString>;
    resourcePath: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ScopeObject = z.infer<typeof scopeObjectSchema>;
type ScopeCondition = ScopeObject | {
    or: ScopeCondition[];
} | {
    and: ScopeCondition[];
} | ScopeCondition[];
declare const scopeConditionSchema: z.ZodType<ScopeCondition>;
declare const verifyAccessInputSchema: z.ZodObject<{
    userId: z.ZodUUID;
    accessRequests: z.ZodType<ScopeCondition, unknown, z.core.$ZodTypeInternals<ScopeCondition, unknown>>;
    jwt: z.ZodOptional<z.ZodObject<{
        sub: z.ZodString;
        iat: z.ZodNumber;
        exp: z.ZodNumber;
        userData: z.ZodOptional<z.ZodObject<{
            referenceId: z.ZodString;
            email: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        user: z.ZodObject<{
            id: z.ZodUUID;
            createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            updatedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            deletedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            email: z.ZodEmail;
            rawAppMetaData: z.ZodAny;
            rawUserMetaData: z.ZodAny;
            isSuperAdmin: z.ZodDefault<z.ZodBoolean>;
            isSsoUser: z.ZodDefault<z.ZodBoolean>;
            emailChangeToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            isBanned: z.ZodOptional<z.ZodNullable<z.ZodDefault<z.ZodBoolean>>>;
            createdAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
            updatedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
            deletedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
            lastSignInAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
            emailConfirmedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
            confirmationSentAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
            recoverySentAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
            emailChangeSentAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
        }, z.core.$strip>;
    }, z.core.$strip>>;
}, z.core.$strip>;
interface VerifyAccessInput extends z.infer<typeof verifyAccessInputSchema> {
}
interface VerifyAccessOutput {
    isVerified: boolean;
}
declare function isScopeObject(condition: ScopeCondition): condition is ScopeObject;
declare function isOrCondition(condition: ScopeCondition): condition is {
    or: ScopeCondition[];
};
declare function isAndCondition(condition: ScopeCondition): condition is {
    and: ScopeCondition[];
};
declare function isImplicitAndCondition(condition: ScopeCondition): condition is ScopeCondition[];

export { revokeRoleFromUserInputSchema as $, assignRoleToUserInputSchema as K, assignRolesToUserInputSchema as M, createRoleInputSchema as N, deleteRoleInputSchema as O, getUserPermissionsInputSchema as P, grantScopeToRoleInputSchema as Q, grantScopeToUserInputSchema as T, grantScopesToUserInputSchema as W, isAndCondition as X, isImplicitAndCondition as Y, isOrCondition as Z, isScopeObject as _, revokeScopeFromRoleInputSchema as a0, revokeScopeFromUserInputSchema as a1, scopeConditionSchema as a2, scopeObjectSchema as a3, updateRoleInputSchema as a4, verifyAccessInputSchema as a5, tables as t };
export type { AssignRoleToUserInput as A, ScopeCondition as B, CreateRoleInput as C, DeleteRoleInput as D, ScopeObject as E, UserRoleInsertType as F, GrantScopeToUserInput as G, UserRoleSelectType as H, UserScopeInsertType as I, UserScopeSelectType as J, LabeledScope as L, RevokeRoleFromUserInput as R, Scope as S, UpdateRoleInput as U, VerifyAccessInput as V, CreateRoleOutput as a, AssignRoleToUserOutput as b, AssignRolesToUserInput as c, AssignRolesToUserOutput as d, RevokeRoleFromUserOutput as e, GrantScopeToUserOutput as f, GrantScopesToUserInput as g, GrantScopesToUserOutput as h, RevokeScopeFromUserInput as i, RevokeScopeFromUserOutput as j, GrantScopeToRoleInput as k, GrantScopeToRoleOutput as l, RevokeScopeFromRoleInput as m, RevokeScopeFromRoleOutput as n, GetAllUserRolesOutput as o, GetPermissionsOutput as p, GetUserPermissionsInput as q, GetUserPermissionsOutput as r, VerifyAccessOutput as s, DeleteRoleOutput as u, UpdateRoleOutput as v, RoleInsertType as w, RoleScopeInsertType as x, RoleScopeSelectType as y, RoleSelectType as z };