import { z } from 'zod';
import config from '../fetch/env/index.js';
export { ACCESS_TYPES, AccessType, AddMemberInput, CreateOrganizationInput, GetMembersResponse, Member, MemberDetails, MemberDetailsSchema, MembersResponseSchema, Organization, PermissionsResponse, PermissionsResponseSchema, RemoveMembersInput, UpdateMemberRoleInput, UpdateOrganizationInput } from './organization/index.js';
export { PaginatedUser, PaginatedUserSchema, USER_ROLES, UserAndProfile, UserAndProfileSchema, UserProfilePaginated, UserProfilePaginatedSchema, UserRole, UserRoles, UserSchema, UserType, UserTypes } from './user/index.js';
export { AbilitiesTuple, Action, AppAbility, Subject, SubjectTuple, actions, subjects } from './abilitiy/ability.js';
export { DbPermission, DbPermissionSchema, Permission, PermissionSchema } from './abilitiy/schemas.js';
export { APIKey, APIKeyAttributes, APPEARANCE_OPTIONS, AppearanceOption, BreakFontColor, DashboardColor, IndicatorColor, IntegrationConfig, KEY_OPTIONS, KEY_STATUS, KeyOption, KeyStatus, LANGUAGE_OPTIONS, LanguageOption, RADIX_ACCENT_COLORS, RADIX_ANY_COLORS_OPTIONS, RADIX_GRAY_COLORS, RADIX_RADIUS, RadixAnyColor, RadixColor, RadixGrayColor, RadixRadius, RadixScaling, SCALING_OPTIONS, SettingsConfig, ThemeConfig, UserPreference, Variables, breakFontColor, fontColor } from './settings/index.js';
import '@casl/ability';
import './groups/index.js';
import './zones/index.js';

declare enum Presence {
    online = "online",
    away = "away",
    busy = "busy",
    offline = "offline",
    deactivated = "deactivated"
}
declare enum StorageType {
    MEM = "memory",
    SQL = "sql",
    NONE = "none",
    Session = "session",
    Cookie = "cookie",
    Local = "local"
}
declare enum RefreshType {
    none = "none",
    ws = "ws",
    periodic = "periodic"
}
declare enum ErrorCode {
    OK = "200",
    BadRequest_400 = "400",
    Unauthorized_401 = "401",
    Forbidden_403 = "403",
    NotFound_404 = "404",
    InternalServerError_500 = "500"
}
declare enum RequestMethod {
    GET = "GET",
    POST = "POST",
    PUT = "PUT",
    DELETE = "DELETE"
}
type BaseUrl = {
    url: string;
    headers: string[];
    clientId?: string;
    clientKey?: string;
    variables?: string[];
};
type FieldType = typeof String | typeof Number | typeof Boolean | (typeof String)[] | (typeof Number)[] | (typeof Boolean)[];
declare enum QueryOp {
    "=" = "=",
    ">" = ">",
    "<" = "<",
    ">=" = ">=",
    "<=" = "<=",
    "!=" = "!=",
    in = "in",
    like = "like",
    between = "between",
    "not in" = "not in",
    "not like" = "not like",
    "not between" = "not between"
}
type Query = {
    key: string;
    op: QueryOp;
    value: FieldType;
};
type Pagination = {
    page: number;
    pageSize: number;
    lastRefresh?: number;
    lastRefreshErrorCode?: ErrorCode;
};
type Meta = {
    totalPages: number;
    totalItems: number;
    lastRefresh?: number;
    lastRefreshErrorCode?: ErrorCode;
    loading?: boolean;
    pages: [
        {
            page: number;
            size: number;
            lastRefresh?: number;
            lastRefreshErrorCode?: ErrorCode;
            loading?: boolean;
        }
    ];
};
type Service = {
    baseUrl: BaseUrl;
    serviceUrl?: BaseUrl;
    queryParams?: Record<string, string>;
    method?: RequestMethod;
    shape?: Record<string, FieldType>;
    storageType?: StorageType;
    refreshType?: RefreshType;
    refreshInterval?: number;
    table?: string;
    mergeOnField?: string[];
    union?: boolean;
    meta?: Meta;
    remoteRoute?: string;
};
declare const AuthUserSchema: z.ZodObject<{
    email: z.ZodString;
    isSuperAdmin: z.ZodBoolean;
    emailVerified: z.ZodBoolean;
    id: z.ZodString;
}, z.core.$strip>;
declare const AuthUserSessionSchema: z.ZodObject<{
    email: z.ZodString;
    isSuperAdmin: z.ZodBoolean;
    emailVerified: z.ZodBoolean;
    id: z.ZodString;
    session: z.ZodObject<{
        id: z.ZodString;
        expiresAt: z.ZodString;
        fresh: z.ZodBoolean;
        userId: z.ZodString;
    }, z.core.$strip>;
}, z.core.$strip>;
declare const UserProfileSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    email: z.ZodString;
    profileImage: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
    avatar: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
    localeId: z.ZodCoercedNumber<unknown>;
}, z.core.$strip>;
type UserProfile = z.infer<typeof UserProfileSchema>;
type AuthUser = z.output<typeof AuthUserSchema>;
type AuthUserSession = z.output<typeof AuthUserSessionSchema>;
type User<TUser> = TUser & {
    email: string;
    emailVerified: boolean;
    slug: string;
    isSuperAdmin: boolean;
    presence?: Presence;
};
type MeUser<TUser, TSession> = User<TUser> & TSession & {
    sessionId: string;
};
declare const passwordSchema: z.ZodString;
declare const cookieSchema: z.ZodString;
declare const entityTypeSchema: z.ZodEnum<{
    USER: "USER";
    ORGANIZATION: "ORGANIZATION";
    WORKSPACE: "WORKSPACE";
    PROJECT: "PROJECT";
}>;
declare const contextEntityTypeSchema: z.ZodEnum<{
    ORGANIZATION: "ORGANIZATION";
    WORKSPACE: "WORKSPACE";
    PROJECT: "PROJECT";
}>;
declare const idSchema: z.ZodString;
declare const slugSchema: z.ZodString;
declare const idOrSlugSchema: z.ZodUnion<[z.ZodString, z.ZodString]>;
declare const tokenSchema: z.ZodObject<{
    token: z.ZodString;
}, z.core.$strip>;
declare const errorSchema: z.ZodObject<{
    message: z.ZodString;
    type: z.ZodString;
    status: z.ZodNumber;
    severity: z.ZodString;
    entityType: z.ZodOptional<z.ZodEnum<{
        USER: "USER";
        ORGANIZATION: "ORGANIZATION";
        WORKSPACE: "WORKSPACE";
        PROJECT: "PROJECT";
    }>>;
    logId: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
    method: z.ZodOptional<z.ZodString>;
    timestamp: z.ZodOptional<z.ZodString>;
    usr: z.ZodOptional<z.ZodString>;
    org: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const failWithErrorSchema: z.ZodObject<{
    success: z.ZodDefault<z.ZodBoolean>;
    error: z.ZodObject<{
        message: z.ZodString;
        type: z.ZodString;
        status: z.ZodNumber;
        severity: z.ZodString;
        entityType: z.ZodOptional<z.ZodEnum<{
            USER: "USER";
            ORGANIZATION: "ORGANIZATION";
            WORKSPACE: "WORKSPACE";
            PROJECT: "PROJECT";
        }>>;
        logId: z.ZodOptional<z.ZodString>;
        path: z.ZodOptional<z.ZodString>;
        method: z.ZodOptional<z.ZodString>;
        timestamp: z.ZodOptional<z.ZodString>;
        usr: z.ZodOptional<z.ZodString>;
        org: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
}, z.core.$strip>;
declare const validSlugSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
declare const validDomainsSchema: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
declare const entityParamSchema: z.ZodObject<{
    idOrSlug: z.ZodUnion<[z.ZodString, z.ZodString]>;
}, z.core.$strip>;
declare const membershipsCountSchema: z.ZodObject<{
    memberships: z.ZodObject<{
        admins: z.ZodNumber;
        members: z.ZodNumber;
        total: z.ZodNumber;
    }, z.core.$strip>;
}, z.core.$strip>;
declare const srcSchema: z.ZodString;
declare const nameSchema: z.ZodString;
declare const colorSchema: z.ZodString;
declare const validUrlSchema: z.ZodString;
declare const presignedUrlSchema: z.ZodObject<{
    url: z.ZodString;
}, z.core.$strip>;
declare const optionalPresignedUrlSchema: z.ZodObject<{
    url: z.ZodNullable<z.ZodString>;
}, z.core.$strip>;
type OptionalPresignedUrl = z.infer<typeof optionalPresignedUrlSchema>;
type Entity = (typeof config.entityTypes)[number];
type ContextEntity = (typeof config.contextEntityTypes)[number];
type OauthProviderOptions = (typeof config.oauthProviderOptions)[number];
type NonEmptyArray<T> = readonly [T, ...T[]];
type ErrorResponse = z.infer<typeof failWithErrorSchema>;
type Env<TUser> = {
    Variables: {
        user: User<TUser>;
        allowedIds: string[];
        disallowedIds: string[];
    };
};
declare const wsMessageActions: readonly ["GET_ONLINE_USERS", "CONNECT", "DISCONNECT"];
type WsMessageAction = (typeof wsMessageActions)[number];
type WsMessage = {
    action: WsMessageAction;
    data: Record<string, string | number | boolean | object>;
    sessionId?: string;
};
declare const GenericResponseSchema: z.ZodObject<{
    message: z.ZodString;
}, z.core.$strip>;
type GenericResponse = z.infer<typeof GenericResponseSchema>;

export { type AuthUser, AuthUserSchema, type AuthUserSession, AuthUserSessionSchema, type BaseUrl, type ContextEntity, type Entity, type Env, ErrorCode, type ErrorResponse, type FieldType, type GenericResponse, GenericResponseSchema, type MeUser, type Meta, type NonEmptyArray, type OauthProviderOptions, type OptionalPresignedUrl, type Pagination, Presence, type Query, QueryOp, RefreshType, RequestMethod, type Service, StorageType, type User, type UserProfile, UserProfileSchema, type WsMessage, type WsMessageAction, colorSchema, contextEntityTypeSchema, cookieSchema, entityParamSchema, entityTypeSchema, errorSchema, failWithErrorSchema, idOrSlugSchema, idSchema, membershipsCountSchema, nameSchema, optionalPresignedUrlSchema, passwordSchema, presignedUrlSchema, slugSchema, srcSchema, tokenSchema, validDomainsSchema, validSlugSchema, validUrlSchema, wsMessageActions };