export type ClientOptions = {
    baseUrl: 'http://localhost:3000' | (string & {});
};
export declare enum Permission {
    ALL_PERMISSIONS = "all_permissions",
    CONTACT_CREATE = "contact.create",
    CONTACT_READ = "contact.read",
    CONTACT_UPDATE = "contact.update",
    CONTACT_DELETE = "contact.delete",
    EVENT_LOG_READ = "event-log.read",
    FILE_READ = "file.read",
    FILE_CREATE = "file.create",
    FILE_DELETE = "file.delete",
    JOBS_READ_INDEX = "jobs.read.index",
    JOBS_READ_DETAIL = "jobs.read.detail",
    NOTIFICATION_READ_OWN = "notification.read.own",
    NOTIFICATION_READ_CONFIG = "notification.read.config",
    NOTIFICATION_UPDATE_READ = "notification.update.read",
    NOTIFICATION_UPDATE_UNREAD = "notification.update.unread",
    NOTIFICATION_PREFERENCES_UPDATE_CHANNEL = "notification.preferences.update.channel",
    NOTIFICATION_PREFERENCES_UPDATE_PRESET = "notification.preferences.update.preset",
    NOTIFICATION_PREFERENCES_UPDATE_TYPES = "notification.preferences.update.types",
    NOTIFICATION_PREFERENCES_READ_OWN = "notification.preferences.read.own",
    NOTIFICATION_MIGRATE_TYPE = "notification.migrate-type",
    NOTIFICATION_SEND_TEST = "notification.send-test",
    ROLE_READ = "role.read",
    ROLE_CREATE = "role.create",
    ROLE_UPDATE = "role.update",
    ROLE_DELETE = "role.delete",
    ROLE_CACHE_CLEAR = "role.cache.clear",
    SEND_PUSH_NOTIFICATION = "send_push_notification",
    TYPESENSE = "typesense",
    USER_READ = "user.read",
    USER_CREATE = "user.create",
    USER_UPDATE = "user.update",
    USER_DELETE = "user.delete",
    TENANT_CREATE = "tenant.create",
    TENANT_READ_INDEX = "tenant.read_index",
    TENANT_READ_DETAIL = "tenant.read_detail",
    TENANT_UPDATE = "tenant.update",
    CBE_SEARCH = "cbe.search"
}
export type ViewPermissionIndexPermissionResponse = {
    name: string;
    key: Permission;
    description: string;
};
export type ViewPermissionIndexGroupResponse = {
    name: string;
    permissions: Array<ViewPermissionIndexPermissionResponse>;
};
export type ViewPermissionIndexResponse = {
    groups: Array<ViewPermissionIndexGroupResponse>;
};
export type CreateTenantCommand = {
    name: string;
    slug: string;
    domain: string;
    oidcIssuer: string;
    oidcClientId: string;
};
export type CreateTenantResponse = {
    uuid: string;
    name: string;
    slug: string;
    oidcIssuer: string;
    oidcClientId: string;
};
export type UpdateTenantCommand = {
    name: string;
    slug: string;
    domain: string | null;
    oidcIssuer?: string;
    oidcClientId?: string;
};
export type ViewTenantDetailResponse = {
    uuid: string;
    createdAt: string;
    updatedAt: string;
    name: string;
    slug: string;
    domain: string | null;
};
export type PaginatedOffsetQuery = {
    limit: number;
    offset: number;
};
export type TenantResponse = {
    uuid: string;
    createdAt: string;
    updatedAt: string;
    name: string;
    slug: string;
    domain: string | null;
};
export type PaginatedOffsetResponseMeta = {
    /**
     * the total amount of items that exist
     */
    total: number;
    /**
     * the amount of items skipped
     */
    offset: number;
    /**
     * the amount of items per response
     */
    limit: number;
};
export type ViewTenantIndexResponse = {
    /**
     * The items for the current page
     */
    items: Array<TenantResponse>;
    meta: PaginatedOffsetResponseMeta;
};
export type GetApiInfoResponse = {
    environment: string;
    /**
     * Commit SHA of the current build
     */
    commit: string;
    /**
     * Version of the current build
     */
    version: string;
    /**
     * Timestamp of the current build
     */
    timestamp: string;
};
export declare enum TypesenseCollectionName {
    USER = "user",
    CONTACT = "contact",
    CBE_ENTERPRISE = "cbe_enterprise",
    CBE_ESTABLISHMENT = "cbe_establishment"
}
export type ViewCollectionIndexResponse = {
    collections: Array<'user' | 'contact' | 'cbe_enterprise' | 'cbe_establishment'>;
};
export type UserNotFoundError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '404';
    code: 'user_not_found';
};
export type SetUserRolesCommand = {
    roleUuids: Array<string>;
};
export type ViewRoleDetailResponse = {
    uuid: string;
    createdAt: string;
    updatedAt: string;
    name: string;
    permissions: Array<Permission>;
    isDefault: boolean;
    isSystemAdmin: boolean;
};
export type ViewMeResponse = {
    uuid: string;
    email: string | null;
    firstName: string | null;
    lastName: string | null;
    tenantUuid: string | null;
    roles: Array<ViewRoleDetailResponse>;
};
export type ViewUserDetailResponse = {
    uuid: string;
    email: string | null;
    firstName: string | null;
    lastName: string | null;
    tenantUuid: string | null;
    roles: Array<ViewRoleDetailResponse>;
};
export type UserIndexRoleView = {
    uuid: string;
    name: string;
};
export type UserIndexView = {
    uuid: string;
    email: string | null;
    firstName: string | null;
    lastName: string | null;
    roles: Array<UserIndexRoleView>;
};
export type ViewUserIndexResponse = {
    /**
     * The items for the current page
     */
    items: Array<UserIndexView>;
    meta: PaginatedOffsetResponseMeta;
};
export type CreateRoleCommand = {
    /**
     * The name of the role
     */
    name: string;
};
export type CreateRoleResponse = {
    uuid: string;
};
export type ClearRolePermissionsCacheCommand = {
    /**
     * clears the cache for all roles when omitted or null
     */
    roleUuids?: Array<string> | null;
};
export type RoleNotFoundError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '404';
    code: 'role_not_found';
};
export type UpdateRoleCommand = {
    /**
     * The name of the role
     */
    name: string;
};
export type RoleResponse = {
    uuid: string;
    createdAt: string;
    updatedAt: string;
    name: string;
    permissions: Array<Permission>;
    isDefault: boolean;
    isSystemAdmin: boolean;
};
export type ViewRoleIndexResponse = {
    items: Array<RoleResponse>;
};
export type UpdateRolesPermissionsCommandItem = {
    roleUuid: string;
    permissions: Array<Permission>;
};
export type UpdateRolesPermissionsCommand = {
    roles: Array<UpdateRolesPermissionsCommandItem>;
};
export declare enum MimeType {
    APPLICATION_PDF = "application/pdf",
    APPLICATION_MSWORD = "application/msword",
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_WORDPROCESSINGML_DOCUMENT = "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
    APPLICATION_VND_MS_POWERPOINT = "application/vnd.ms-powerpoint",
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_PRESENTATIONML_PRESENTATION = "application/vnd.openxmlformats-officedocument.presentationml.presentation",
    TEXT_PLAIN = "text/plain",
    TEXT_HTML = "text/html",
    TEXT_CSV = "text/csv",
    IMAGE_JPEG = "image/jpeg",
    IMAGE_PNG = "image/png",
    IMAGE_TIFF = "image/tiff",
    IMAGE_BMP = "image/bmp",
    IMAGE_HEIC = "image/heic",
    IMAGE_WEBP = "image/webp",
    IMAGE_GIF = "image/gif",
    APPLICATION_OCTET_STREAM = "application/octet-stream"
}
export type CreateFileCommand = {
    name: string;
    mimeType: MimeType;
    isPublic?: boolean;
};
export type CreateFileResponse = {
    uuid: string;
    name: string;
    mimeType: MimeType | null;
    uploadUrl: string;
};
export type FileNotFoundError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '404';
    code: 'file_not_found';
};
export type ConfirmFileUploadCommand = {
    blurHash: string | null;
};
export type CoordinatesCommand = {
    longitude: number;
    latitude: number;
};
export type AddressCommand = {
    placeName: string | null;
    placeId: string | null;
    country: string | null;
    city: string | null;
    postalCode: string | null;
    streetName: string | null;
    streetNumber: string | null;
    unit: string | null;
    coordinates: CoordinatesCommand | null;
};
/**
 * a ISO 4217 currency code
 */
export declare enum Currency {
    AFN = "AFN",
    EUR = "EUR",
    ALL = "ALL",
    DZD = "DZD",
    USD = "USD",
    AOA = "AOA",
    XCD = "XCD",
    ARS = "ARS",
    AMD = "AMD",
    AWG = "AWG",
    AUD = "AUD",
    AZN = "AZN",
    BSD = "BSD",
    BHD = "BHD",
    BDT = "BDT",
    BBD = "BBD",
    BYN = "BYN",
    BZD = "BZD",
    XOF = "XOF",
    BMD = "BMD",
    INR = "INR",
    BTN = "BTN",
    BOB = "BOB",
    BOV = "BOV",
    BAM = "BAM",
    BWP = "BWP",
    NOK = "NOK",
    BRL = "BRL",
    BND = "BND",
    BGN = "BGN",
    BIF = "BIF",
    CVE = "CVE",
    KHR = "KHR",
    XAF = "XAF",
    CAD = "CAD",
    KYD = "KYD",
    CLP = "CLP",
    CLF = "CLF",
    CNY = "CNY",
    COP = "COP",
    COU = "COU",
    KMF = "KMF",
    CDF = "CDF",
    NZD = "NZD",
    CRC = "CRC",
    CUP = "CUP",
    ANG = "ANG",
    CZK = "CZK",
    DKK = "DKK",
    DJF = "DJF",
    DOP = "DOP",
    EGP = "EGP",
    SVC = "SVC",
    ERN = "ERN",
    SZL = "SZL",
    ETB = "ETB",
    FKP = "FKP",
    FJD = "FJD",
    XPF = "XPF",
    GMD = "GMD",
    GEL = "GEL",
    GHS = "GHS",
    GIP = "GIP",
    GTQ = "GTQ",
    GBP = "GBP",
    GNF = "GNF",
    GYD = "GYD",
    HTG = "HTG",
    HNL = "HNL",
    HKD = "HKD",
    HUF = "HUF",
    ISK = "ISK",
    IDR = "IDR",
    XDR = "XDR",
    IRR = "IRR",
    IQD = "IQD",
    ILS = "ILS",
    JMD = "JMD",
    JPY = "JPY",
    JOD = "JOD",
    KZT = "KZT",
    KES = "KES",
    KPW = "KPW",
    KRW = "KRW",
    KWD = "KWD",
    KGS = "KGS",
    LAK = "LAK",
    LBP = "LBP",
    LSL = "LSL",
    ZAR = "ZAR",
    LRD = "LRD",
    LYD = "LYD",
    CHF = "CHF",
    MOP = "MOP",
    MKD = "MKD",
    MGA = "MGA",
    MWK = "MWK",
    MYR = "MYR",
    MVR = "MVR",
    MRU = "MRU",
    MUR = "MUR",
    XUA = "XUA",
    MXN = "MXN",
    MXV = "MXV",
    MDL = "MDL",
    MNT = "MNT",
    MAD = "MAD",
    MZN = "MZN",
    MMK = "MMK",
    NAD = "NAD",
    NPR = "NPR",
    NIO = "NIO",
    NGN = "NGN",
    OMR = "OMR",
    PKR = "PKR",
    PAB = "PAB",
    PGK = "PGK",
    PYG = "PYG",
    PEN = "PEN",
    PHP = "PHP",
    PLN = "PLN",
    QAR = "QAR",
    RON = "RON",
    RUB = "RUB",
    RWF = "RWF",
    SHP = "SHP",
    WST = "WST",
    STN = "STN",
    SAR = "SAR",
    RSD = "RSD",
    SCR = "SCR",
    SLE = "SLE",
    SGD = "SGD",
    XSU = "XSU",
    SBD = "SBD",
    SOS = "SOS",
    SSP = "SSP",
    LKR = "LKR",
    SDG = "SDG",
    SRD = "SRD",
    SEK = "SEK",
    CHE = "CHE",
    CHW = "CHW",
    SYP = "SYP",
    TWD = "TWD",
    TJS = "TJS",
    TZS = "TZS",
    THB = "THB",
    TOP = "TOP",
    TTD = "TTD",
    TND = "TND",
    TRY = "TRY",
    TMT = "TMT",
    UGX = "UGX",
    UAH = "UAH",
    AED = "AED",
    USN = "USN",
    UYU = "UYU",
    UYI = "UYI",
    UYW = "UYW",
    UZS = "UZS",
    VUV = "VUV",
    VES = "VES",
    VED = "VED",
    VND = "VND",
    YER = "YER",
    ZMW = "ZMW",
    ZWG = "ZWG",
    XBA = "XBA",
    XBB = "XBB",
    XBC = "XBC",
    XBD = "XBD",
    XTS = "XTS",
    XXX = "XXX",
    XAU = "XAU",
    XPD = "XPD",
    XPT = "XPT",
    XAG = "XAG"
}
export type MonetaryDto = {
    amount: number;
    /**
     * a ISO 4217 currency code
     */
    currency: Currency;
    precision: number;
};
export type CreateContactCommand = {
    firstName: string | null;
    lastName: string | null;
    email: string | null;
    phone: string | null;
    address: AddressCommand | null;
    fileUuid: string | null;
    avatarUuid: string | null;
    discount: MonetaryDto | null;
    balance: MonetaryDto | null;
    birthDate: string | null;
};
export type CreateContactResponse = {
    uuid: string;
};
export type ContactNotFoundError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '404';
    code: 'contact_not_found';
};
export type UpdateContactCommand = {
    firstName: string | null;
    lastName: string | null;
    email: string | null;
    phone: string | null;
    isActive: boolean;
    address: AddressCommand | null;
    fileUuid: string | null;
    avatarUuid: string | null;
    discount: MonetaryDto | null;
    balance: MonetaryDto | null;
    birthDate: string | null;
};
export type CoordinatesResponse = {
    longitude: number;
    latitude: number;
};
export type AddressResponse = {
    placeName: string | null;
    placeId: string | null;
    country: string | null;
    city: string | null;
    postalCode: string | null;
    streetName: string | null;
    streetNumber: string | null;
    unit: string | null;
    coordinates: CoordinatesResponse | null;
};
export type FileResponse = {
    uuid: string;
    name: string;
    mimeType: MimeType;
    blurHash: string | null;
};
export type PresignedFileVariantResponse = {
    label: string;
    url: string;
};
export type PresignedFileResponse = {
    uuid: string;
    name: string;
    mimeType: MimeType | null;
    url: string;
    blurHash: string | null;
    variants: Array<PresignedFileVariantResponse>;
};
export type ViewContactDetailResponse = {
    uuid: string;
    createdAt: string;
    updatedAt: string;
    isActive: boolean;
    firstName: string | null;
    lastName: string | null;
    email: string | null;
    phone: string | null;
    address: AddressResponse | null;
    file: FileResponse | null;
    avatar: PresignedFileResponse | null;
    discount: MonetaryDto | null;
    balance: MonetaryDto | null;
    birthDate: string | null;
};
export declare enum ViewContactIndexSortQueryKey {
    NAME = "name"
}
export declare enum SortDirection {
    ASC = "asc",
    DESC = "desc"
}
export type ViewContactIndexSortQuery = {
    key: ViewContactIndexSortQueryKey;
    order: SortDirection;
};
export type ViewContactIndexFilterQuery = {
    isActive?: string;
};
export type ContactResponse = {
    uuid: string;
    isActive: boolean;
    name: string;
    email: string | null;
    phone: string | null;
    address: AddressResponse | null;
};
export type ViewContactIndexResponse = {
    /**
     * The items for the current page
     */
    items: Array<ContactResponse>;
    meta: PaginatedOffsetResponseMeta;
};
export declare enum UiTheme {
    LIGHT = "light",
    DARK = "dark",
    SYSTEM = "system"
}
export declare enum Locale {
    EN_US = "en-US",
    NL_BE = "nl-BE",
    FR_BE = "fr-BE"
}
export declare enum FontSize {
    SMALLER = "smaller",
    SMALL = "small",
    DEFAULT = "default",
    LARGE = "large",
    LARGER = "larger"
}
export type UpdateUiPreferencesCommand = {
    theme?: UiTheme;
    language?: Locale;
    fontSize?: FontSize;
    showShortcuts?: boolean;
    reduceMotion?: boolean;
    highContrast?: boolean;
};
export type ViewUiPreferencesResponse = {
    theme: UiTheme;
    language: Locale;
    fontSize: FontSize;
    showShortcuts: boolean;
    reduceMotion: boolean;
    highContrast: boolean;
};
export type CreateOneSignalTokenResponse = {
    token: string;
    userUuid: string;
};
export type Translations = {
    nl?: string;
    en?: string;
};
export type SendPushNotificationCommand = {
    name: string;
    title: Translations;
    description: Translations;
    userUuids: Array<string>;
};
export declare enum SubjectType {
    CONTACT = "contact",
    FILE = "file",
    ROLE = "role",
    USER = "user",
    TENANT = "tenant"
}
export type ViewDomainEventLogIndexFilterQuery = {
    subjectType?: SubjectType;
    subjectId?: string;
    userUuid?: string;
};
export type ViewDomainEventLogIndexQueryKey = {
    createdAt: string;
    uuid: string;
};
export type ViewDomainEventLogIndexPaginationQuery = {
    limit: number;
    key?: ViewDomainEventLogIndexQueryKey | null;
};
export declare enum DomainEventType {
    CONTACT_CREATED = "contact.created",
    CONTACT_UPDATED = "contact.updated",
    CONTACT_DELETED = "contact.deleted",
    FILE_CREATED = "file.created",
    FILE_UPLOADED = "file.uploaded",
    NOTIFICATION_CREATED = "notification.created",
    NOTIFICATION_READ = "notification.read",
    NOTIFICATION_READ_ALL = "notification.read.all",
    NOTIFICATION_UNREAD = "notification.unread",
    NOTIFICATION_TYPES_MIGRATED = "notification.types.migrated",
    NOTIFICATION_PREFERENCE_PRESET_UPDATED = "notification.preference.preset.updated",
    ROLE_CREATED = "role.created",
    ROLE_DELETED = "role.deleted",
    ROLE_RENAMED = "role.renamed",
    ROLE_PERMISSIONS_UPDATED = "role.permissions.updated",
    ROLE_PERMISSIONS_CACHE_CLEARED = "role.permissions.cache.cleared",
    TEST_NOTIFICATION_SENT = "test-notification.sent",
    USER_CREATED = "user.created",
    USER_UPDATED = "user.updated",
    USER_ROLE_ASSIGNED = "user.role-assigned",
    USER_ROLES_SET = "user.roles-set",
    USER_NOTIFICATION_CREATED = "user.notification.created",
    USER_DEFAULT_NOTIFICATION_PREFERENCES_ASSIGNED = "user.default-notification-preferences.assigned",
    TENANT_CREATED = "tenant.created",
    TENANT_UPDATED = "tenant.updated"
}
export type ViewDomainEventLogIndexItemResponse = {
    uuid: string;
    createdAt: string;
    version: number;
    source: string;
    userUuid: string | null;
    message: string;
    type: DomainEventType;
    subjectType: SubjectType | null;
    subjectId: string | null;
    content: {
        [key: string]: unknown;
    };
};
export type ViewDomainEventLogIndexResponseMeta = {
    next: ViewDomainEventLogIndexQueryKey | null;
};
export type ViewDomainEventLogIndexResponse = {
    items: Array<ViewDomainEventLogIndexItemResponse>;
    meta: ViewDomainEventLogIndexResponseMeta;
};
export declare enum GlobalSearchCollectionName {
    USER = "user",
    CONTACT = "contact"
}
export type SearchCollectionsFilterContactQuery = {
    isActive?: boolean;
};
export type SearchCollectionsFilterQuery = {
    collections?: Array<GlobalSearchCollectionName>;
    contact?: SearchCollectionsFilterContactQuery;
};
export type SearchCollectionsQueryKey = {
    offset: number;
};
export type SearchCollectionPaginationQuery = {
    key?: SearchCollectionsQueryKey;
};
export type SearchCollectionUserResponse = {
    uuid: string;
    name: string;
    email: {
        [key: string]: unknown;
    } | null;
};
export type SearchCollectionContactResponse = {
    uuid: string;
    isActive: boolean;
    name: string;
    email: string | null;
    phone: string | null;
    address: AddressResponse | null;
};
export type SearchCollectionsResponseItem = {
    collection: GlobalSearchCollectionName;
    entity: SearchCollectionUserResponse | SearchCollectionContactResponse;
    text_match: number;
};
export type SearchCollectionsMetaResponse = {
    next: SearchCollectionsQueryKey | null;
};
export type SearchCollectionsResponse = {
    items: Array<SearchCollectionsResponseItem>;
    meta: SearchCollectionsMetaResponse;
};
export declare enum NotificationPreset {
    ALL = "all",
    DEFAULT = "default",
    CUSTOM = "custom",
    NONE = "none"
}
export declare enum NotificationType {
    USER_CREATED = "user.created",
    SYSTEM_TEST_NOTIFICATION = "system.test-notification"
}
export type PreferenceTypes = {
    email: Array<NotificationType>;
    sms: Array<NotificationType>;
    app: Array<NotificationType>;
    push: Array<NotificationType>;
};
export type GetMyNotificationPreferencesResponse = {
    preset: NotificationPreset;
    emailEnabled: boolean;
    smsEnabled: boolean;
    appEnabled: boolean;
    pushEnabled: boolean;
    preferences: PreferenceTypes;
};
export declare enum NotificationChannel {
    EMAIL = "email",
    SMS = "sms",
    APP = "app",
    PUSH = "push"
}
export type NotificationTypeChannelConfig = {
    channel: NotificationChannel;
    defaultValue: boolean;
    isSupported: boolean;
};
export type ViewNotificationTypeConfigTypeResponse = {
    key: NotificationType;
    description: string;
    channelConfigs: Array<NotificationTypeChannelConfig>;
};
export type ViewNotificationTypesConfigGroupResponse = {
    name: string;
    description: string;
    types: Array<ViewNotificationTypeConfigTypeResponse>;
};
export type GetNotificationTypesConfigResponse = {
    groups: Array<ViewNotificationTypesConfigGroupResponse>;
};
export type UpdateMyChannelNotificationPreferenceCommand = {
    channel: NotificationChannel;
    isEnabled: boolean;
};
export type SendTestNotificationCommand = {
    message: string;
};
export type GetMyNotificationsFilterQuery = {
    onlyUnread?: string;
};
export type GetMyNotificationsQueryKey = {
    createdAt: string;
    notificationUuid: string;
};
export type GetMyNotificationsPaginationQuery = {
    limit: number;
    key?: GetMyNotificationsQueryKey | null;
};
export type CreatedByUserResponse = {
    uuid: string;
    name: string;
};
export type TestNotificationContent = {
    message: string;
};
export type SystemTestNotificationNotification = {
    createdAt: string;
    readAt: string | null;
    notificationUuid: string;
    createdByUser: CreatedByUserResponse | null;
    message: string;
    type: 'system.test-notification';
    meta: TestNotificationContent;
};
export type GetMyNotificationsResponseMeta = {
    next: GetMyNotificationsQueryKey | null;
};
export type GetMyNotificationsResponse = {
    items: Array<SystemTestNotificationNotification>;
    meta: GetMyNotificationsResponseMeta;
};
export type ViewUnreadNotificationsCountResponse = {
    amount: number;
    exceedsLimit: boolean;
};
export type UserNotificationNotFoundError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '404';
    code: 'user_notification_not_found';
};
export type UpdateMyNotificationTypePreferenceCommand = {
    channel: NotificationChannel;
    isEnabled: boolean;
    types: Array<NotificationType>;
};
export type UpdateMyNotificationPreferencePresetCommand = {
    preset: NotificationPreset;
};
export type MigrationAlreadyPerformedErrorMeta = {
    type: Array<NotificationType>;
};
export type MigrationAlreadyPerformedError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '400';
    code: 'migration_already_performed';
    /**
     * a meta object containing non-standard meta-information about the error
     */
    meta: MigrationAlreadyPerformedErrorMeta;
};
export type MigrateNotificationTypesCommand = {
    types: Array<NotificationType>;
};
export declare enum ViewJobsIndexSortQueryKey {
    CREATED_AT = "createdAt"
}
export type ViewJobsIndexSortQuery = {
    key: ViewJobsIndexSortQueryKey;
    order: SortDirection;
};
export declare enum QueueName {
    SYSTEM = "system"
}
export type ViewJobsIndexFilterQuery = {
    queueNames?: Array<QueueName>;
};
export type ViewJobsIndexQueryKey = {
    createdAt?: string;
    id: string;
};
export type ViewJobsIndexPaginationQuery = {
    limit: number;
    key?: ViewJobsIndexQueryKey | null;
};
export declare enum JobStatus {
    CREATED = "created",
    ACTIVE = "active",
    COMPLETED = "completed",
    RETRY = "retry",
    FAILED = "failed",
    CANCELLED = "cancelled"
}
export type ViewJobsIndexItemResponse = {
    queueName: QueueName;
    id: string;
    name: string;
    status: JobStatus;
    createdAt: string;
    completedAt: string | null;
};
export type ViewJobsIndexResponseMeta = {
    next: ViewJobsIndexQueryKey | null;
};
export type ViewJobsIndexResponse = {
    items: Array<ViewJobsIndexItemResponse>;
    meta: ViewJobsIndexResponseMeta;
};
export type JobNotFoundError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '404';
    code: 'job_not_found';
};
export type ViewJobDetailResponse = {
    id: string;
    queueName: QueueName;
    priority: number;
    name: string;
    data: {
        [key: string]: unknown;
    };
    status: JobStatus;
    retryLimit: number;
    retryCount: number;
    retryDelay: number;
    retryBackoff: boolean;
    startAfter: string;
    startedAt: string | null;
    singletonKey: string | null;
    singletonOn: string | null;
    expireIn: {
        [key: string]: unknown;
    };
    createdAt: string;
    completedAt: string | null;
    keepUntil: string;
    output: {
        [key: string]: unknown;
    } | null;
    deadLetter: string | null;
    policy: string | null;
};
export declare enum CbeEnterpriseStatus {
    ACTIVE = "active",
    INACTIVE = "inactive"
}
export type SearchCbeEnterprisesView = {
    enterpriseNumber: string;
    status: CbeEnterpriseStatus;
    startDate: string | null;
    name: string | null;
    abbreviation: string | null;
    phone: string | null;
    fax: string | null;
    email: string | null;
    website: string | null;
    address: AddressResponse | null;
};
export type SearchCbeEnterprisesResponse = {
    /**
     * The items for the current page
     */
    items: Array<SearchCbeEnterprisesView>;
    meta: PaginatedOffsetResponseMeta;
};
export type SearchCbeEstablishmentsFilterQuery = {
    enterpriseNumber?: string;
};
export type SearchCbeEstablishmentsView = {
    establishmentNumber: string;
    enterpriseNumber: string;
    startDate: string | null;
    commercialName: string | null;
    address: AddressResponse | null;
};
export type SearchCbeEstablishmentResponse = {
    /**
     * The items for the current page
     */
    items: Array<Array<unknown>>;
    meta: PaginatedOffsetResponseMeta;
    results: Array<SearchCbeEstablishmentsView>;
};
export type InternalServerApiError = {
    /**
     * a human-readable explanation specific to this occurrence of the problem
     */
    detail?: string;
    status: '500';
    code: 'internal_server_error';
};
export type ViewPermissionIndexV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/permissions';
};
export type ViewPermissionIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewPermissionIndexV1Error = ViewPermissionIndexV1Errors[keyof ViewPermissionIndexV1Errors];
export type ViewPermissionIndexV1Responses = {
    200: ViewPermissionIndexResponse;
};
export type ViewPermissionIndexV1Response = ViewPermissionIndexV1Responses[keyof ViewPermissionIndexV1Responses];
export type ViewTenantIndexV1Data = {
    body?: never;
    path?: never;
    query?: {
        pagination?: PaginatedOffsetQuery;
        search?: string;
    };
    url: '/api/v1/tenants';
};
export type ViewTenantIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewTenantIndexV1Error = ViewTenantIndexV1Errors[keyof ViewTenantIndexV1Errors];
export type ViewTenantIndexV1Responses = {
    200: ViewTenantIndexResponse;
};
export type ViewTenantIndexV1Response = ViewTenantIndexV1Responses[keyof ViewTenantIndexV1Responses];
export type CreateTenantV1Data = {
    body: CreateTenantCommand;
    path?: never;
    query?: never;
    url: '/api/v1/tenants';
};
export type CreateTenantV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type CreateTenantV1Error = CreateTenantV1Errors[keyof CreateTenantV1Errors];
export type CreateTenantV1Responses = {
    201: CreateTenantResponse;
};
export type CreateTenantV1Response = CreateTenantV1Responses[keyof CreateTenantV1Responses];
export type ViewTenantDetailV1Data = {
    body?: never;
    path: {
        uuid: string;
    };
    query?: never;
    url: '/api/v1/tenants/{uuid}';
};
export type ViewTenantDetailV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewTenantDetailV1Error = ViewTenantDetailV1Errors[keyof ViewTenantDetailV1Errors];
export type ViewTenantDetailV1Responses = {
    200: ViewTenantDetailResponse;
};
export type ViewTenantDetailV1Response = ViewTenantDetailV1Responses[keyof ViewTenantDetailV1Responses];
export type UpdateTenantV1Data = {
    body: UpdateTenantCommand;
    path: {
        uuid: string;
    };
    query?: never;
    url: '/api/v1/tenants/{uuid}';
};
export type UpdateTenantV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<unknown>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateTenantV1Error = UpdateTenantV1Errors[keyof UpdateTenantV1Errors];
export type UpdateTenantV1Responses = {
    204: void;
};
export type UpdateTenantV1Response = UpdateTenantV1Responses[keyof UpdateTenantV1Responses];
export type GetApiInfoData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api';
};
export type GetApiInfoErrors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type GetApiInfoError = GetApiInfoErrors[keyof GetApiInfoErrors];
export type GetApiInfoResponses = {
    200: GetApiInfoResponse;
};
export type GetApiInfoResponse2 = GetApiInfoResponses[keyof GetApiInfoResponses];
export type MigrateCollectionsV1Data = {
    body?: never;
    path?: never;
    query: {
        fresh: boolean;
        collections?: Array<TypesenseCollectionName>;
    };
    url: '/api/v1/typesense/migrate';
};
export type MigrateCollectionsV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type MigrateCollectionsV1Error = MigrateCollectionsV1Errors[keyof MigrateCollectionsV1Errors];
export type MigrateCollectionsV1Responses = {
    200: unknown;
};
export type ImportCollectionsV1Data = {
    body?: never;
    path?: never;
    query?: {
        collections?: Array<TypesenseCollectionName>;
    };
    url: '/api/v1/typesense/import';
};
export type ImportCollectionsV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ImportCollectionsV1Error = ImportCollectionsV1Errors[keyof ImportCollectionsV1Errors];
export type ImportCollectionsV1Responses = {
    200: unknown;
};
export type ViewCollectionsV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/typesense/collections/details';
};
export type ViewCollectionsV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewCollectionsV1Error = ViewCollectionsV1Errors[keyof ViewCollectionsV1Errors];
export type ViewCollectionsV1Responses = {
    200: unknown;
};
export type ViewCollectionIndexV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/typesense/collections';
};
export type ViewCollectionIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewCollectionIndexV1Error = ViewCollectionIndexV1Errors[keyof ViewCollectionIndexV1Errors];
export type ViewCollectionIndexV1Responses = {
    200: ViewCollectionIndexResponse;
};
export type ViewCollectionIndexV1Response = ViewCollectionIndexV1Responses[keyof ViewCollectionIndexV1Responses];
export type SetUserRolesV1Data = {
    body: SetUserRolesCommand;
    path: {
        user: string;
    };
    query?: never;
    url: '/api/v1/users/{user}/role';
};
export type SetUserRolesV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<UserNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type SetUserRolesV1Error = SetUserRolesV1Errors[keyof SetUserRolesV1Errors];
export type ViewMeV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/users/me';
};
export type ViewMeV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<UserNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewMeV1Error = ViewMeV1Errors[keyof ViewMeV1Errors];
export type ViewMeV1Responses = {
    /**
     * User details retrieved
     */
    200: ViewMeResponse;
};
export type ViewMeV1Response = ViewMeV1Responses[keyof ViewMeV1Responses];
export type ViewUserDetailV1Data = {
    body?: never;
    path: {
        uuid: string;
    };
    query?: never;
    url: '/api/v1/users/{uuid}';
};
export type ViewUserDetailV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<UserNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewUserDetailV1Error = ViewUserDetailV1Errors[keyof ViewUserDetailV1Errors];
export type ViewUserDetailV1Responses = {
    /**
     * User details retrieved
     */
    200: ViewUserDetailResponse;
};
export type ViewUserDetailV1Response = ViewUserDetailV1Responses[keyof ViewUserDetailV1Responses];
export type ViewUserIndexV1Data = {
    body?: never;
    path?: never;
    query?: {
        pagination?: PaginatedOffsetQuery;
        search?: string;
    };
    url: '/api/v1/users';
};
export type ViewUserIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewUserIndexV1Error = ViewUserIndexV1Errors[keyof ViewUserIndexV1Errors];
export type ViewUserIndexV1Responses = {
    /**
     * Users retrieved
     */
    200: ViewUserIndexResponse;
};
export type ViewUserIndexV1Response = ViewUserIndexV1Responses[keyof ViewUserIndexV1Responses];
export type ViewRoleIndexV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/roles';
};
export type ViewRoleIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewRoleIndexV1Error = ViewRoleIndexV1Errors[keyof ViewRoleIndexV1Errors];
export type ViewRoleIndexV1Responses = {
    /**
     * The roles has been successfully received.
     */
    200: ViewRoleIndexResponse;
};
export type ViewRoleIndexV1Response = ViewRoleIndexV1Responses[keyof ViewRoleIndexV1Responses];
export type UpdateRolesPermissionsV1Data = {
    body: UpdateRolesPermissionsCommand;
    path?: never;
    query?: never;
    url: '/api/v1/roles';
};
export type UpdateRolesPermissionsV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<RoleNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateRolesPermissionsV1Error = UpdateRolesPermissionsV1Errors[keyof UpdateRolesPermissionsV1Errors];
export type UpdateRolesPermissionsV1Responses = {
    204: void;
};
export type UpdateRolesPermissionsV1Response = UpdateRolesPermissionsV1Responses[keyof UpdateRolesPermissionsV1Responses];
export type CreateRoleV1Data = {
    body: CreateRoleCommand;
    path?: never;
    query?: never;
    url: '/api/v1/roles';
};
export type CreateRoleV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type CreateRoleV1Error = CreateRoleV1Errors[keyof CreateRoleV1Errors];
export type CreateRoleV1Responses = {
    201: CreateRoleResponse;
};
export type CreateRoleV1Response = CreateRoleV1Responses[keyof CreateRoleV1Responses];
export type ClearRolePermissionsCacheV1Data = {
    body: ClearRolePermissionsCacheCommand;
    path?: never;
    query?: never;
    url: '/api/v1/roles/clear-cache';
};
export type ClearRolePermissionsCacheV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ClearRolePermissionsCacheV1Error = ClearRolePermissionsCacheV1Errors[keyof ClearRolePermissionsCacheV1Errors];
export type ClearRolePermissionsCacheV1Responses = {
    204: void;
};
export type ClearRolePermissionsCacheV1Response = ClearRolePermissionsCacheV1Responses[keyof ClearRolePermissionsCacheV1Responses];
export type DeleteRoleV1Data = {
    body?: never;
    path: {
        role: string;
    };
    query?: never;
    url: '/api/v1/roles/{role}';
};
export type DeleteRoleV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<RoleNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type DeleteRoleV1Error = DeleteRoleV1Errors[keyof DeleteRoleV1Errors];
export type DeleteRoleV1Responses = {
    204: void;
};
export type DeleteRoleV1Response = DeleteRoleV1Responses[keyof DeleteRoleV1Responses];
export type ViewRoleDetailV1Data = {
    body?: never;
    path: {
        role: string;
    };
    query?: never;
    url: '/api/v1/roles/{role}';
};
export type ViewRoleDetailV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<RoleNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewRoleDetailV1Error = ViewRoleDetailV1Errors[keyof ViewRoleDetailV1Errors];
export type ViewRoleDetailV1Responses = {
    /**
     * The role has been successfully received.
     */
    200: ViewRoleDetailResponse;
};
export type ViewRoleDetailV1Response = ViewRoleDetailV1Responses[keyof ViewRoleDetailV1Responses];
export type UpdateRoleV1Data = {
    body: UpdateRoleCommand;
    path: {
        role: string;
    };
    query?: never;
    url: '/api/v1/roles/{role}';
};
export type UpdateRoleV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<RoleNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateRoleV1Error = UpdateRoleV1Errors[keyof UpdateRoleV1Errors];
export type UpdateRoleV1Responses = {
    204: void;
};
export type UpdateRoleV1Response = UpdateRoleV1Responses[keyof UpdateRoleV1Responses];
export type CreateFileV1Data = {
    body: CreateFileCommand;
    path?: never;
    query?: never;
    url: '/api/v1/files';
};
export type CreateFileV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type CreateFileV1Error = CreateFileV1Errors[keyof CreateFileV1Errors];
export type CreateFileV1Responses = {
    201: CreateFileResponse;
};
export type CreateFileV1Response = CreateFileV1Responses[keyof CreateFileV1Responses];
export type ConfirmFileUploadV1Data = {
    body?: never;
    path: {
        file: string;
    };
    query?: never;
    url: '/api/v1/files/{file}/confirm-upload';
};
export type ConfirmFileUploadV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<FileNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ConfirmFileUploadV1Error = ConfirmFileUploadV1Errors[keyof ConfirmFileUploadV1Errors];
export type ConfirmFileUploadV1Responses = {
    204: void;
};
export type ConfirmFileUploadV1Response = ConfirmFileUploadV1Responses[keyof ConfirmFileUploadV1Responses];
export type ConfirmFileUploadV2Data = {
    body: ConfirmFileUploadCommand;
    path: {
        file: string;
    };
    query?: never;
    url: '/api/v2/files/{file}/confirm-upload';
};
export type ConfirmFileUploadV2Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<FileNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ConfirmFileUploadV2Error = ConfirmFileUploadV2Errors[keyof ConfirmFileUploadV2Errors];
export type ConfirmFileUploadV2Responses = {
    204: void;
};
export type ConfirmFileUploadV2Response = ConfirmFileUploadV2Responses[keyof ConfirmFileUploadV2Responses];
export type DownloadFileV1Data = {
    body?: never;
    path: {
        file: string;
    };
    query?: never;
    url: '/api/v1/files/{file}/download';
};
export type DownloadFileV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<FileNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type DownloadFileV1Error = DownloadFileV1Errors[keyof DownloadFileV1Errors];
export type DownloadPublicFileV1Data = {
    body?: never;
    path: {
        file: string;
    };
    query: {
        token: string;
    };
    url: '/api/v1/public/files/{file}/download';
};
export type DownloadPublicFileV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<FileNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type DownloadPublicFileV1Error = DownloadPublicFileV1Errors[keyof DownloadPublicFileV1Errors];
export type ViewContactIndexV1Data = {
    body?: never;
    path?: never;
    query?: {
        pagination?: PaginatedOffsetQuery;
        sort?: Array<ViewContactIndexSortQuery>;
        filter?: ViewContactIndexFilterQuery;
        search?: string;
    };
    url: '/api/v1/contacts';
};
export type ViewContactIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewContactIndexV1Error = ViewContactIndexV1Errors[keyof ViewContactIndexV1Errors];
export type ViewContactIndexV1Responses = {
    200: ViewContactIndexResponse;
};
export type ViewContactIndexV1Response = ViewContactIndexV1Responses[keyof ViewContactIndexV1Responses];
export type CreateContactV1Data = {
    body: CreateContactCommand;
    path?: never;
    query?: never;
    url: '/api/v1/contacts';
};
export type CreateContactV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<FileNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type CreateContactV1Error = CreateContactV1Errors[keyof CreateContactV1Errors];
export type CreateContactV1Responses = {
    201: CreateContactResponse;
};
export type CreateContactV1Response = CreateContactV1Responses[keyof CreateContactV1Responses];
export type DeleteContactV1Data = {
    body?: never;
    path: {
        uuid: string;
    };
    query?: never;
    url: '/api/v1/contacts/{uuid}';
};
export type DeleteContactV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<ContactNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type DeleteContactV1Error = DeleteContactV1Errors[keyof DeleteContactV1Errors];
export type DeleteContactV1Responses = {
    204: void;
};
export type DeleteContactV1Response = DeleteContactV1Responses[keyof DeleteContactV1Responses];
export type ViewContactDetailV1Data = {
    body?: never;
    path: {
        uuid: string;
    };
    query?: never;
    url: '/api/v1/contacts/{uuid}';
};
export type ViewContactDetailV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewContactDetailV1Error = ViewContactDetailV1Errors[keyof ViewContactDetailV1Errors];
export type ViewContactDetailV1Responses = {
    200: ViewContactDetailResponse;
};
export type ViewContactDetailV1Response = ViewContactDetailV1Responses[keyof ViewContactDetailV1Responses];
export type UpdateContactV1Data = {
    body: UpdateContactCommand;
    path: {
        uuid: string;
    };
    query?: never;
    url: '/api/v1/contacts/{uuid}';
};
export type UpdateContactV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<ContactNotFoundError | FileNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateContactV1Error = UpdateContactV1Errors[keyof UpdateContactV1Errors];
export type UpdateContactV1Responses = {
    204: void;
};
export type UpdateContactV1Response = UpdateContactV1Responses[keyof UpdateContactV1Responses];
export type ViewUiPreferencesV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/me/ui-preferences';
};
export type ViewUiPreferencesV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewUiPreferencesV1Error = ViewUiPreferencesV1Errors[keyof ViewUiPreferencesV1Errors];
export type ViewUiPreferencesV1Responses = {
    200: ViewUiPreferencesResponse;
};
export type ViewUiPreferencesV1Response = ViewUiPreferencesV1Responses[keyof ViewUiPreferencesV1Responses];
export type UpdateUiPreferencesV1Data = {
    body: UpdateUiPreferencesCommand;
    path?: never;
    query?: never;
    url: '/api/v1/me/ui-preferences';
};
export type UpdateUiPreferencesV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateUiPreferencesV1Error = UpdateUiPreferencesV1Errors[keyof UpdateUiPreferencesV1Errors];
export type UpdateUiPreferencesV1Responses = {
    200: unknown;
};
export type CreateOneSignalTokenV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/onesignal/token';
};
export type CreateOneSignalTokenV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type CreateOneSignalTokenV1Error = CreateOneSignalTokenV1Errors[keyof CreateOneSignalTokenV1Errors];
export type CreateOneSignalTokenV1Responses = {
    201: CreateOneSignalTokenResponse;
};
export type CreateOneSignalTokenV1Response = CreateOneSignalTokenV1Responses[keyof CreateOneSignalTokenV1Responses];
export type SendPushNotificationV1Data = {
    body: SendPushNotificationCommand;
    path?: never;
    query?: never;
    url: '/api/v1/onesignal/push-notification';
};
export type SendPushNotificationV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type SendPushNotificationV1Error = SendPushNotificationV1Errors[keyof SendPushNotificationV1Errors];
export type SendPushNotificationV1Responses = {
    201: unknown;
};
export type ViewDomainEventLogIndexV1Data = {
    body?: never;
    path?: never;
    query?: {
        filter?: ViewDomainEventLogIndexFilterQuery;
        pagination?: ViewDomainEventLogIndexPaginationQuery;
    };
    url: '/api/v1/event-logs';
};
export type ViewDomainEventLogIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewDomainEventLogIndexV1Error = ViewDomainEventLogIndexV1Errors[keyof ViewDomainEventLogIndexV1Errors];
export type ViewDomainEventLogIndexV1Responses = {
    200: ViewDomainEventLogIndexResponse;
};
export type ViewDomainEventLogIndexV1Response = ViewDomainEventLogIndexV1Responses[keyof ViewDomainEventLogIndexV1Responses];
export type SearchCollectionsV1Data = {
    body?: never;
    path?: never;
    query: {
        filter?: SearchCollectionsFilterQuery;
        search: string;
        pagination?: SearchCollectionPaginationQuery;
    };
    url: '/api/v1/search';
};
export type SearchCollectionsV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type SearchCollectionsV1Error = SearchCollectionsV1Errors[keyof SearchCollectionsV1Errors];
export type SearchCollectionsV1Responses = {
    200: SearchCollectionsResponse;
};
export type SearchCollectionsV1Response = SearchCollectionsV1Responses[keyof SearchCollectionsV1Responses];
export type GetMyNotificationPreferencesV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/me/notification-preferences';
};
export type GetMyNotificationPreferencesV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type GetMyNotificationPreferencesV1Error = GetMyNotificationPreferencesV1Errors[keyof GetMyNotificationPreferencesV1Errors];
export type GetMyNotificationPreferencesV1Responses = {
    200: GetMyNotificationPreferencesResponse;
};
export type GetMyNotificationPreferencesV1Response = GetMyNotificationPreferencesV1Responses[keyof GetMyNotificationPreferencesV1Responses];
export type GetNotificationTypesConfigV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/notification-preferences/config';
};
export type GetNotificationTypesConfigV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type GetNotificationTypesConfigV1Error = GetNotificationTypesConfigV1Errors[keyof GetNotificationTypesConfigV1Errors];
export type GetNotificationTypesConfigV1Responses = {
    200: GetNotificationTypesConfigResponse;
};
export type GetNotificationTypesConfigV1Response = GetNotificationTypesConfigV1Responses[keyof GetNotificationTypesConfigV1Responses];
export type UpdateMyChannelNotificationPreferenceV1Data = {
    body: UpdateMyChannelNotificationPreferenceCommand;
    path?: never;
    query?: never;
    url: '/api/v1/me/notification-preferences/channels';
};
export type UpdateMyChannelNotificationPreferenceV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateMyChannelNotificationPreferenceV1Error = UpdateMyChannelNotificationPreferenceV1Errors[keyof UpdateMyChannelNotificationPreferenceV1Errors];
export type UpdateMyChannelNotificationPreferenceV1Responses = {
    204: void;
};
export type UpdateMyChannelNotificationPreferenceV1Response = UpdateMyChannelNotificationPreferenceV1Responses[keyof UpdateMyChannelNotificationPreferenceV1Responses];
export type SendTestNotificationV1Data = {
    body: SendTestNotificationCommand;
    path?: never;
    query?: never;
    url: '/api/v1/notifications/test-notification';
};
export type SendTestNotificationV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type SendTestNotificationV1Error = SendTestNotificationV1Errors[keyof SendTestNotificationV1Errors];
export type SendTestNotificationV1Responses = {
    204: void;
};
export type SendTestNotificationV1Response = SendTestNotificationV1Responses[keyof SendTestNotificationV1Responses];
export type GetMyNotificationsV1Data = {
    body?: never;
    path?: never;
    query?: {
        filter?: GetMyNotificationsFilterQuery;
        pagination?: GetMyNotificationsPaginationQuery;
    };
    url: '/api/v1/me/notifications';
};
export type GetMyNotificationsV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type GetMyNotificationsV1Error = GetMyNotificationsV1Errors[keyof GetMyNotificationsV1Errors];
export type GetMyNotificationsV1Responses = {
    200: GetMyNotificationsResponse;
};
export type GetMyNotificationsV1Response = GetMyNotificationsV1Responses[keyof GetMyNotificationsV1Responses];
export type ViewUnreadNotificationsCountV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/me/notifications/unread-count';
};
export type ViewUnreadNotificationsCountV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewUnreadNotificationsCountV1Error = ViewUnreadNotificationsCountV1Errors[keyof ViewUnreadNotificationsCountV1Errors];
export type ViewUnreadNotificationsCountV1Responses = {
    200: ViewUnreadNotificationsCountResponse;
};
export type ViewUnreadNotificationsCountV1Response = ViewUnreadNotificationsCountV1Responses[keyof ViewUnreadNotificationsCountV1Responses];
export type ViewUserNotificationDetailV1Data = {
    body?: never;
    path: {
        notificationUuid: string;
    };
    query?: never;
    url: '/api/v1/me/notifications/{notificationUuid}';
};
export type ViewUserNotificationDetailV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<UserNotificationNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewUserNotificationDetailV1Error = ViewUserNotificationDetailV1Errors[keyof ViewUserNotificationDetailV1Errors];
export type ViewUserNotificationDetailV1Responses = {
    200: SystemTestNotificationNotification;
};
export type ViewUserNotificationDetailV1Response = ViewUserNotificationDetailV1Responses[keyof ViewUserNotificationDetailV1Responses];
export type MarkAllNotificationAsReadV1Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/me/notifications/mark-as-read';
};
export type MarkAllNotificationAsReadV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type MarkAllNotificationAsReadV1Error = MarkAllNotificationAsReadV1Errors[keyof MarkAllNotificationAsReadV1Errors];
export type MarkAllNotificationAsReadV1Responses = {
    204: void;
};
export type MarkAllNotificationAsReadV1Response = MarkAllNotificationAsReadV1Responses[keyof MarkAllNotificationAsReadV1Responses];
export type UpdateMyNotificationTypePreferenceV1Data = {
    body: UpdateMyNotificationTypePreferenceCommand;
    path?: never;
    query?: never;
    url: '/api/v1/me/notification-preferences/types';
};
export type UpdateMyNotificationTypePreferenceV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateMyNotificationTypePreferenceV1Error = UpdateMyNotificationTypePreferenceV1Errors[keyof UpdateMyNotificationTypePreferenceV1Errors];
export type UpdateMyNotificationTypePreferenceV1Responses = {
    204: void;
};
export type UpdateMyNotificationTypePreferenceV1Response = UpdateMyNotificationTypePreferenceV1Responses[keyof UpdateMyNotificationTypePreferenceV1Responses];
export type MarkNotificationAsReadV1Data = {
    body?: never;
    path: {
        notificationUuid: string;
    };
    query?: never;
    url: '/api/v1/me/notifications/{notificationUuid}/mark-as-read';
};
export type MarkNotificationAsReadV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<UserNotificationNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type MarkNotificationAsReadV1Error = MarkNotificationAsReadV1Errors[keyof MarkNotificationAsReadV1Errors];
export type MarkNotificationAsReadV1Responses = {
    204: void;
};
export type MarkNotificationAsReadV1Response = MarkNotificationAsReadV1Responses[keyof MarkNotificationAsReadV1Responses];
export type MarkNotificationAsUnreadV1Data = {
    body?: never;
    path: {
        notificationUuid: string;
    };
    query?: never;
    url: '/api/v1/me/notifications/{notificationUuid}/mark-as-unread';
};
export type MarkNotificationAsUnreadV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<UserNotificationNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type MarkNotificationAsUnreadV1Error = MarkNotificationAsUnreadV1Errors[keyof MarkNotificationAsUnreadV1Errors];
export type MarkNotificationAsUnreadV1Responses = {
    204: void;
};
export type MarkNotificationAsUnreadV1Response = MarkNotificationAsUnreadV1Responses[keyof MarkNotificationAsUnreadV1Responses];
export type UpdateMyNotificationPreferencePresetV1Data = {
    body: UpdateMyNotificationPreferencePresetCommand;
    path?: never;
    query?: never;
    url: '/api/v1/me/notification-preferences/preset';
};
export type UpdateMyNotificationPreferencePresetV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type UpdateMyNotificationPreferencePresetV1Error = UpdateMyNotificationPreferencePresetV1Errors[keyof UpdateMyNotificationPreferencePresetV1Errors];
export type UpdateMyNotificationPreferencePresetV1Responses = {
    204: void;
};
export type UpdateMyNotificationPreferencePresetV1Response = UpdateMyNotificationPreferencePresetV1Responses[keyof UpdateMyNotificationPreferencePresetV1Responses];
export type MigrateNotificationTypesV1Data = {
    body: MigrateNotificationTypesCommand;
    path?: never;
    query?: never;
    url: '/api/v1/notifications/migrate';
};
export type MigrateNotificationTypesV1Errors = {
    400: {
        traceId?: string | null;
        errors?: Array<MigrationAlreadyPerformedError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type MigrateNotificationTypesV1Error = MigrateNotificationTypesV1Errors[keyof MigrateNotificationTypesV1Errors];
export type MigrateNotificationTypesV1Responses = {
    204: void;
};
export type MigrateNotificationTypesV1Response = MigrateNotificationTypesV1Responses[keyof MigrateNotificationTypesV1Responses];
export type ViewJobsIndexV1Data = {
    body?: never;
    path?: never;
    query?: {
        sort?: Array<ViewJobsIndexSortQuery>;
        filter?: ViewJobsIndexFilterQuery;
        pagination?: ViewJobsIndexPaginationQuery;
    };
    url: '/api/v1/jobs';
};
export type ViewJobsIndexV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewJobsIndexV1Error = ViewJobsIndexV1Errors[keyof ViewJobsIndexV1Errors];
export type ViewJobsIndexV1Responses = {
    200: ViewJobsIndexResponse;
};
export type ViewJobsIndexV1Response = ViewJobsIndexV1Responses[keyof ViewJobsIndexV1Responses];
export type ViewJobDetailV1Data = {
    body?: never;
    path: {
        jobId: string;
    };
    query?: never;
    url: '/api/v1/jobs/{jobId}';
};
export type ViewJobDetailV1Errors = {
    404: {
        traceId?: string | null;
        errors?: Array<JobNotFoundError>;
    };
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type ViewJobDetailV1Error = ViewJobDetailV1Errors[keyof ViewJobDetailV1Errors];
export type ViewJobDetailV1Responses = {
    200: ViewJobDetailResponse;
};
export type ViewJobDetailV1Response = ViewJobDetailV1Responses[keyof ViewJobDetailV1Responses];
export type SearchCbeEnterprisesV1Data = {
    body?: never;
    path?: never;
    query: {
        pagination?: PaginatedOffsetQuery;
        search: string;
    };
    url: '/api/v1/cbe/enterprises';
};
export type SearchCbeEnterprisesV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type SearchCbeEnterprisesV1Error = SearchCbeEnterprisesV1Errors[keyof SearchCbeEnterprisesV1Errors];
export type SearchCbeEnterprisesV1Responses = {
    200: SearchCbeEnterprisesResponse;
};
export type SearchCbeEnterprisesV1Response = SearchCbeEnterprisesV1Responses[keyof SearchCbeEnterprisesV1Responses];
export type SearchCbeEstablishmentsCbeV1Data = {
    body?: never;
    path?: never;
    query: {
        pagination?: PaginatedOffsetQuery;
        filter?: SearchCbeEstablishmentsFilterQuery;
        search: string;
    };
    url: '/api/v1/cbe/establishments';
};
export type SearchCbeEstablishmentsCbeV1Errors = {
    500: {
        traceId?: string | null;
        errors?: Array<InternalServerApiError>;
    };
};
export type SearchCbeEstablishmentsCbeV1Error = SearchCbeEstablishmentsCbeV1Errors[keyof SearchCbeEstablishmentsCbeV1Errors];
export type SearchCbeEstablishmentsCbeV1Responses = {
    200: SearchCbeEstablishmentResponse;
};
export type SearchCbeEstablishmentsCbeV1Response = SearchCbeEstablishmentsCbeV1Responses[keyof SearchCbeEstablishmentsCbeV1Responses];