import { UUID } from '../uuid';
import * as z from 'zod/v4';
import { EventIndex } from './EventIndex';
import { ActionCreationMetadata, RegistrationCreationMetadata } from './EventMetadata';
import { RecordScopeV2, UserScopeV2 } from '../scopes';
import { SystemContext, UserContext } from '../users/User';
/** @deprecated Moving on, location types are arbitrary and defined by the country config. */
export declare const LocationTypeV1: z.ZodEnum<{
    ADMIN_STRUCTURE: "ADMIN_STRUCTURE";
    HEALTH_FACILITY: "HEALTH_FACILITY";
    CRVS_OFFICE: "CRVS_OFFICE";
}>;
export type LocationTypeV1 = z.infer<typeof LocationTypeV1>;
export declare const AdministrativeArea: z.ZodObject<{
    id: z.core.$ZodBranded<z.ZodUUID, "UUID", "out">;
    name: z.ZodString;
    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    parentId: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "UUID", "out">>;
    validUntil: z.ZodNullable<z.ZodISODateTime>;
}, z.core.$strip>;
export type AdministrativeArea = z.infer<typeof AdministrativeArea>;
export declare const Location: z.ZodObject<{
    id: z.core.$ZodBranded<z.ZodUUID, "UUID", "out">;
    name: z.ZodString;
    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    administrativeAreaId: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "UUID", "out">>;
    validUntil: z.ZodNullable<z.ZodISODateTime>;
    locationType: z.ZodNullable<z.ZodString>;
}, z.core.$strip>;
export type Location = z.infer<typeof Location>;
type WrapArrayPreserveNullish<V> = V extends readonly any[] ? V : NonNullable<V>[] | Extract<V, null | undefined>;
/**
 * For type T, convert fields K to arrays. If field is string, convert to string[].
 */
type ToArrayFields<T, K extends PropertyKey> = T extends unknown ? T extends object ? {
    [P in keyof T]: P extends K ? WrapArrayPreserveNullish<T[P]> : T[P];
} : T : never;
/**
 * Event index type where all location fields are arrays representing full location hierarchy.
 */
export type EventIndexWithAdministrativeHierarchy = Omit<ToArrayFields<EventIndex, 'createdAtLocation' | 'updatedAtLocation' | 'placeOfEvent'>, 'legalStatuses'> & {
    legalStatuses: {
        DECLARED: ToArrayFields<ActionCreationMetadata, 'createdAtLocation'> | undefined;
        REGISTERED: ToArrayFields<RegistrationCreationMetadata, 'createdAtLocation'> | undefined;
    };
};
/**
 * Given indexed event and resolved scope, determine if the scope allows access to the event.
 *
 * All of the options within the scope must be satisfied for access to be granted.
 * Return false early to break out of checks as soon as possible - if any option is not satisfied, the scope does not allow access to the event, so no need to check further options.
 *
 */
export declare function canAccessEventWithScope(event: Partial<EventIndexWithAdministrativeHierarchy>, scope: RecordScopeV2, user: UserContext | SystemContext, customActionType?: string): boolean;
export type UserWithResolvedHierarchy = {
    role: string;
    administrativeHierarchy: UUID[];
    primaryOfficeId: UUID;
};
export declare function canAccessUserWithScope({ userToAccess, scope, user }: {
    userToAccess: UserWithResolvedHierarchy;
    scope: UserScopeV2;
    user: UserContext | SystemContext;
}): boolean;
export declare function canAccessOtherUserWithScopes({ scopes, userToAccess, user }: {
    scopes: UserScopeV2[];
    userToAccess: UserWithResolvedHierarchy;
    user: UserContext | SystemContext;
}): boolean;
/**
 * Given indexed event and list of resolved scopes, determine if any of the scopes allow access to the event.
 *
 * One of the scopes must allow access for the event to be accessible.
 */
export declare function userCanAccessEventWithScopes(event: Partial<EventIndexWithAdministrativeHierarchy>, scopes: RecordScopeV2[], user: UserContext | SystemContext, customActionType?: string): boolean;
export declare function getAdministrativeAreaHierarchy(administrativeAreaId: string | undefined | null, administrativeAreas: Map<UUID, AdministrativeArea>): {
    id: string & z.core.$brand<"UUID">;
    name: string;
    parentId: (string & z.core.$brand<"UUID">) | null;
    validUntil: string | null;
    externalId?: string | null | undefined;
}[];
/**
 * Resolves a location or administrative area UUID into a root-first hierarchy of UUIDs.
 *
 * If the ID refers to a `Location` (e.g. CRVS office), the hierarchy includes
 * the administrative area ancestors followed by the location itself.
 * If the ID refers to an `AdministrativeArea`, returns the area's ancestor chain (root-first).
 *
 * Uses `getAdministrativeAreaHierarchy` which returns leaf-first order,
 * so the result is reversed to match the root-first convention used by the server.
 */
export declare function getLocationHierarchy(selectedId: UUID, context: {
    administrativeAreas: Map<UUID, AdministrativeArea>;
    locations: Map<UUID, Location>;
}): UUID[];
export {};
//# sourceMappingURL=locations.d.ts.map