import { scalar } from "./base.scalar";
import { entity } from "./base.entity";
import { pair } from "./base.pair";
import { subscriptionEntity } from "./subscriptionEntity";
import { planEntity } from "./planEntity";
import { projectEntity } from "./projectEntity";
import { assetEntity } from "./assetEntity";
import { languageEnum } from "./languageEnum";
import { countryEnum } from "./countryEnum";
import { pegiEntity } from "./pegiEntity";
import { creatorEnum } from "./creatorEnum";
import { userEntity } from "./userEntity";
import { profileRoleEnum } from "./profileRoleEnum";
import { profileKindEnum } from "./profileKindEnum";
import { subscriptionStatusEnum } from "./subscriptionStatusEnum";
import { profileStatusEnum } from "./profileStatusEnum";
import { freshnessEnum } from "./freshnessEnum";
import { timezoneLookup } from "./timezoneLookup";
import { mobileAppLookup } from "./mobileAppLookup";
import { mobileAppVersionLookup } from "./mobileAppVersionLookup";
import { themeLookup } from "./themeLookup";
import { segmentEnum } from "./segmentEnum";
import { languageAcceptLookup } from "./languageAcceptLookup";
import { domainLookup } from "./domainLookup";
import { regionLookup } from "./regionLookup";
import { cityLookup } from "./cityLookup";
import { metroLookup } from "./metroLookup";
import { browserLookup } from "./browserLookup";
import { engineLookup } from "./engineLookup";
import { operatingSystemLookup } from "./operatingSystemLookup";
import { cpuArchitectureLookup } from "./cpuArchitectureLookup";
import { deviceVendorLookup } from "./deviceVendorLookup";
import { deviceTypeLookup } from "./deviceTypeLookup";
import { deviceModelLookup } from "./deviceModelLookup";
import { applicationEnum } from "./applicationEnum";
import { platformEnum } from "./platformEnum";
import { clientLookup } from "./clientLookup";
export declare namespace profileEntity {
    type Id = scalar.Uuid;
    interface Doc extends entity.Doc<Id> {
        project?: projectEntity.Id;
        user?: userEntity.Id;
        owner?: Id;
        role?: profileRoleEnum.Id;
        name?: scalar.Title;
        _name?: scalar.Alpha;
        pin?: scalar.Alpha;
        activated?: scalar.Boolean;
        avatar?: assetEntity.Id;
        pegi?: pegiEntity.Id;
        language?: languageEnum.Id;
        country?: countryEnum.Id;
        timezone?: scalar.Title;
        theme?: scalar.Title;
        nameSet?: scalar.Boolean;
        freshness?: freshnessEnum.Id;
        playedAny?: scalar.Boolean;
        registered?: Id;
        refreshedAt?: scalar.IsoDatetime;
        plan?: planEntity.Id;
        subscription?: subscriptionEntity.Id;
        subscribeCount?: scalar.Integer;
        kind?: profileKindEnum.Id;
        effectiveKind?: profileKindEnum.Id;
        status?: profileStatusEnum.Id;
        anonymous?: scalar.Boolean;
        regularDeadline?: scalar.IsoDatetime;
        trialDeadline?: scalar.IsoDatetime;
        chargingDeadline?: scalar.IsoDatetime;
        _allFamily?: scalar.Integer;
        _activatedFamily?: scalar.Integer;
        _allKids?: scalar.Integer;
        _activatedKids?: scalar.Integer;
        _allAdults?: scalar.Integer;
        _activatedAdults?: scalar.Integer;
        _checksum?: scalar.String;
        email?: scalar.Email;
        phone?: scalar.Alpha;
        firstLogin?: scalar.Boolean;
        firstSubscribe?: scalar.Boolean;
    }
    interface Filter extends entity.Filter {
        project?: Array<projectEntity.Id>;
        activated?: scalar.Boolean;
    }
    interface Service extends entity.Service<Id, Doc, Pair, Filter> {
    }
    type Table = entity.Wrapper<Id, Doc>;
    interface View extends entity.View<Id> {
        name?: scalar.Title;
        avatar?: assetEntity.View;
        language?: languageEnum.Pair;
        country?: countryEnum.Pair;
        timezone?: scalar.Title;
        pegi?: pegiEntity.View;
        role?: profileRoleEnum.Pair;
        kind?: profileKindEnum.Pair;
        effectiveKind?: profileKindEnum.Pair;
        creator?: creatorEnum.Pair;
        theme?: scalar.Title;
        nameSet?: scalar.Boolean;
        isKid?: scalar.Boolean;
        anonymous?: scalar.Boolean;
        hasPin?: scalar.Boolean;
    }
    interface Pair extends pair.Core<Id> {
    }
    type IdOrPair = Id | Pair;
    interface UpsertDto extends scalar.AnyObject {
        user: userEntity.Id;
        name?: scalar.Title;
        email?: scalar.Email;
        remote?: scalar.Unknown;
    }
    interface SubscribeDto {
        subscription?: subscriptionEntity.Id;
        reason?: scalar.Title;
        remote?: scalar.Unknown;
    }
    interface UnsubscribeDto {
        subscription?: subscriptionEntity.Id;
        status?: subscriptionStatusEnum.Id;
        reason?: scalar.Title;
        remote?: scalar.Unknown;
    }
    interface CancelSubscriptionDto {
        subscription?: subscriptionEntity.Id;
        reason?: scalar.Title;
        remote?: scalar.Unknown;
    }
    interface LoginDto {
        reason?: scalar.Title;
        remote?: scalar.Unknown;
    }
    interface LogoutDto {
        reason?: scalar.Title;
        remote?: scalar.Unknown;
    }
    interface Context extends scalar.AnyObject {
        language: Array<languageEnum.Id>;
        country: Array<countryEnum.Id>;
        timezone: Array<timezoneLookup.Id>;
        mobileApp: Array<mobileAppLookup.Id>;
        mobileAppVersion: Array<mobileAppVersionLookup.Id>;
        role: Array<profileRoleEnum.Id>;
        kind: Array<profileKindEnum.Id>;
        effectiveKind: Array<profileKindEnum.Id>;
        status: Array<profileStatusEnum.Id>;
        theme: Array<themeLookup.Id>;
        freshness: Array<freshnessEnum.Id>;
        segment: Array<segmentEnum.Id>;
        pegiProfile: Array<pegiEntity.Id>;
        childCount: Array<scalar.Integer>;
        languageAgent: Array<languageEnum.Id>;
        languageAccept: Array<languageAcceptLookup.Id>;
        domain: Array<domainLookup.Id>;
        countryAgent: Array<countryEnum.Id>;
        timezoneAgent: Array<timezoneLookup.Id>;
        offset: Array<scalar.Integer>;
        region: Array<regionLookup.Id>;
        city: Array<cityLookup.Id>;
        metro: Array<metroLookup.Id>;
        browser: Array<browserLookup.Id>;
        engine: Array<engineLookup.Id>;
        operatingSystem: Array<operatingSystemLookup.Id>;
        cpuArchitecture: Array<cpuArchitectureLookup.Id>;
        deviceVendor: Array<deviceVendorLookup.Id>;
        deviceType: Array<deviceTypeLookup.Id>;
        deviceModel: Array<deviceModelLookup.Id>;
        application: Array<applicationEnum.Id>;
        platform: Array<platformEnum.Id>;
        client: Array<clientLookup.Id>;
    }
}