import { BaseField } from '@dvn/core/doldurma/src/BaseField';
import { DvnAppViewConfig } from '@dvn/core/models/view-config';
export declare function clone(obj: any): any;
export declare type Language = 'en' | 'tr';
export declare enum Role {
  Admin = "admin",
  Mentee = "mentee",
  Mentor = "mentor"
}
export declare enum Collection {
  Activities = "activities",
  Announcements = "announcements",
  Availabilities = "availabilities",
  Configs = "configs",
  Conversations = "conversations",
  Events = "events",
  Feedbacks = "feedbacks",
  Forms = "forms",
  FormResponses = "formResponses",
  Groups = "groups",
  Invitations = "invitations",
  MeetingGoalConfigs = "meetingGoalConfigs",
  Mentorships = "mentorships",
  Messages = "messages",
  Metadatas = "metadatas",
  Notes = "notes",
  Organisations = "organisations",
  Sessions = "sessions",
  Subscriptions = "subscriptions",
  Users = "users",
  WhiteLabels = "whiteLabels"
}
export declare class MentornityModel {
  createdAt: number;
  updatedAt: number;
  _id?: string;
  Id(): string;
}
export declare class ModelReference extends MentornityModel {
  _id: string;
  _class: Collection;
  static decode(json: any): ModelReference;
  _type: 'reference';
  constructor(_id: string, _class: Collection);
}
export declare class Activity extends MentornityModel {
  static decode(json: any): Activity;
  notifies: string[];
  organisation: ModelReference;
  on: Event | User;
  object: Availability | Event | Note;
  relates: string[];
  subject: User;
  verb: ActivityVerb;
}
export declare enum ActivityVerb {
  AddEventNote = "addEventNote",
  CancelAvailability = "cancelAvailability",
  CancelEvent = "cancelEvent",
  CreateAvailability = "createAvailability",
  CreateEvent = "createEvent",
  UpdateEvent = "updateEvent",
  SetEventNotOccurred = "setEventNotOccurred"
}
export declare class Announcement extends MentornityModel {
  static decode(json: any): Announcement;
  title: string;
  content: string;
  target: AnnouncementTarget;
  sendEmail: boolean;
  status: AnnouncementStatus;
}
export declare enum AnnouncementStatus {
  Published = "published",
  Unpublished = "unpublished"
}
export declare enum AnnouncementTarget {
  All = "all",
  Mentee = "mentee",
  Mentor = "mentor"
}
export declare class Availability extends MentornityModel {
  static decode(json: any): Availability;
  availability: ModelReference | Availability;
  blockedSlots: number[];
  createdBy: ModelReference;
  owner: ModelReference;
  endDate: number;
  location: Location;
  meetingBreaks: number;
  meetingDuration: number;
  organisation: ModelReference | Organisation;
  mentorship: ModelReference;
  startDate: number;
  status: EventStatus;
  type: 'meeting';
  cancelInfo: EventCancelInfo;
  meetingGoalIdentifier: string;
  slots: Slot[];
  slotCount: number;
  ref(): ModelReference;
}
export declare class Slot {
  id: string;
  startDate: number;
  endDate: number;
  isBlocked: boolean;
}
export declare class AuthPlatform {
  static decode(json: any): AuthPlatform;
  id: string;
  domain: string;
}
export declare enum ConfigMenteeType {
  Individual = "individual",
  Group = "group",
  GroupedIndividual = "groupedIndividual"
}
export declare enum ConfigMentorMenteeSubscription {
  Implicit = "implicit",
  Restricted = "restricted"
}
export declare class Config extends MentornityModel {
  static decode(json: any): Config;
  adminWebAppHomeMessage: AdminHomeMessage;
  activityRules: ConfigActivityRules;
  canAdminsEditMemberProfile: boolean;
  feedback: FeedbackConfig;
  language: Language;
  menteeType: ConfigMenteeType;
  mentorMenteeSubscription: ConfigMentorMenteeSubscription;
  metadatas: ConfigMetadatas;
  organisation: ModelReference;
  profileFieldVisibilities: {
    mentee: IProfileFieldVisibilities;
    mentor: IProfileFieldVisibilities;
  };
  routes: ConfigRoutes;
  terms: string;
  termReplacements: ConfigTermReplacements;
  termTags: string[];
  userLimit: number;
  subscriptionConfig: SubscriptionConfig;
  subscriptionConfigEnabled: boolean;
  subscriptionNotificationsEnabled: boolean;
  timeZone: string;
  meetingSettings: {
    meetingLimitOfMenteesForWeek: number;
    meetingLimitOfMenteesForWeekPerSuite: number;
    minRemainingTimeForMeetingCreation: number;
    minRemainingTimeForMeetingCancellation: number;
    mentorsCanCreateAvailability: boolean;
    mentorsCanCreateMeeting: boolean;
    menteesCanCreateMeeting: boolean;
  };
  welcomeMessages: {
    mentee: string;
    mentor: string;
  };
  welcomeStepVisibilities: {
    mentee: IMenteeWelcomeStepVisibilities;
    mentor: IMentorWelcomeStepVisibilities;
  };
  finishMessages: {
    mentee: string;
    mentor: string;
  };
  contactInfoVisibility: {
    mentee: InfoVisibility;
    mentor: InfoVisibility;
  };
  conversationPermissions: {
    mentee: InfoVisibility;
    mentor: InfoVisibility;
  };
  metadataVisibility: {
    mentee: InfoVisibility;
    mentor: InfoVisibility;
  };
  webAppConfiguration: {
    membershipForm: boolean;
  };
}
export interface IProfileFieldVisibilities {
  bio: boolean;
  skills: boolean;
  title: boolean;
}
export interface IMenteeWelcomeStepVisibilities {
  welcomeMessage: boolean;
  profile: boolean;
  metadata: boolean;
  group: boolean;
  finishMessage: boolean;
}
export interface IMentorWelcomeStepVisibilities {
  welcomeMessage: boolean;
  profile: boolean;
  metadata: boolean;
  mentorship: boolean;
  mentorshipLimit: boolean;
  availability: boolean;
  finishMessage: boolean;
}
export interface ILoginResponse {
  accessToken: string;
  client: string;
  createdAt: number;
  failureReason: string;
  ip: string;
  lastVisitedPage: string;
  sessionCount: number;
  status: string;
  updatedAt: number;
  user: User;
  userAgent: string;
  _id: string;
}
export interface IPrivacyPolicy {
  content: string;
  createdAt: number;
  language: string;
  title: string;
  type: string;
  updatedAt: number;
  version: string;
  _id: string;
}
export declare enum InfoVisibility {
  none = "none",
  subscribedOnly = "subscribedOnly",
  allMentees = "allMentees",
  allMentors = "allMentors",
  everyone = "everyone"
}
export declare class Conversation extends MentornityModel {
  static decode(json: any): Conversation;
  organisation: Organisation;
  participants: Array<(ModelReference | User | Group)>;
}
export declare class FormData {
  fields: BaseField[];
  showFieldOrder?: boolean;
  version?: number;
  constructor(fields: BaseField[], showFieldOrder?: boolean, version?: number);
}
export declare class FeedbackConfig {
  mentee: FormData;
  mentor: FormData;
}
export declare class ConfigActivityRules {
  expectedTags: string[][];
  unexpectedTags: string[];
  metadataRules: any;
}
export declare class AdminHomeMessage {
  content: any[];
  version: string;
}
export declare class ConfigMetadatas {
  mentee: BaseField[];
  mentor: BaseField[];
  menteesCanEditMetadata: boolean;
  mentorsCanEditMetadata: boolean;
}
export declare class Feedback extends MentornityModel {
  static decode(json: any): Feedback;
  organisation: ModelReference | Organisation;
  createdBy: ModelReference | User;
  event: ModelReference | Event;
}
export declare class Invitation extends MentornityModel {
  static decode(json: any): Invitation;
  accountType: Role;
  createdBy: ModelReference | User;
  issuedFor: string;
  firstName: string;
  lastName: string;
  language: Language;
  skills: string[];
  organisation: ModelReference | Organisation;
  invitee: ModelReference | User;
  status: InvitationStatus;
  constructor(init?: Partial<Invitation>);
}
export declare enum InvitationStatus {
  Accepted = "accepted",
  Pending = "pending"
}
export declare class Metadata {
  static decode(json: any): Metadata;
  data: any;
  createdBy: ModelReference | User;
  boundTo: ModelReference | User;
}
export declare class ConfigRoutes {
  admin: string[];
  anonymous: string[];
  mentee: string[];
  mentor: string[];
}
export declare class ConfigTermReplacements {
  mentor: string;
  mentee: string;
  group: string;
  suite: string;
}
export declare class Context {
  static decode(json: any): Context;
  availableRoles: string[];
  config: Config;
  meetingGoalConfig: MeetingGoalConfig;
  organisation: Organisation;
  role: string;
}
export declare class Event extends MentornityModel {
  static decode(json: any): Event;
  gcID: string;
  attendees: User[];
  createdBy: ModelReference | User;
  endDate: number;
  guests: Array<(ModelReference | User | Group)>;
  location: Location;
  organisation: ModelReference | Organisation;
  availability: ModelReference | Availability;
  startDate: number;
  status: EventStatus;
  type: 'meeting';
  cancelInfo: EventCancelInfo;
  meetingGoalIdentifier: string;
  ref(): ModelReference;
}
export declare class EventCancelInfo {
  reason: string;
  canceledBy: User;
  guestCausedCancellation: ModelReference | User | Group;
  canceledAt: number;
  isProblematic: boolean;
}
export declare enum EventStatus {
  Active = "active",
  Canceled = "canceled"
}
export declare class Group extends MentornityModel {
  static decode(json: any): Group;
  createdBy: User;
  title: string;
  description: string;
  imageUrl: string;
  coverUrl: string;
  members: Array<(User | ModelReference)>;
  organisation: Organisation | ModelReference;
  termTags: string[];
  status: 'active' | 'passive';
  linkedInUrl: string;
  webSiteUrl: string;
  twitterUrl: string;
  facebookUrl: string;
  videoUrl: string;
  type: 'mentee' | 'mentor';
  subscriptions?: Subscription[];
  ref(): ModelReference;
  isSuite(): boolean;
}
export declare class Location {
  address: string;
  type: string;
}
export declare class MeetingGoal {
  identifier: string;
  meetingTitle: string;
  periodEndDate: number;
  periodStartDate: number;
  specifications: {
    mentee: MeetingGoalSpecification;
    mentor: MeetingGoalSpecification;
  };
}
export declare class MeetingGoalSpecification {
  description: string;
  postMeetingForm: MeetingGoalForms;
  preMeetingForm: MeetingGoalForms;
}
export declare class MeetingGoalForms {
  fields: any[];
  showResultsToAllGuests: boolean;
}
export declare class MeetingGoalConfig extends MentornityModel {
  static decode(json: any): MeetingGoalConfig;
  meetingGoals: MeetingGoal[];
}
export declare class Mentorship extends MentornityModel {
  static decode(json: any): Mentorship;
  audience: string;
  description: string;
  organisation: Organisation | ModelReference;
  owner: User | ModelReference;
  meetingCreationRule: any;
  status: 'active' | 'passive';
  subscriptionLimit: number;
  title: string;
  ref(): ModelReference;
}
export declare class Message extends MentornityModel {
  static decode(json: any): Message;
  content: string;
  organisation: Organisation;
  createdBy: ModelReference | User;
  conversation: ModelReference | Conversation;
  readBy: object;
}
export declare class Note extends MentornityModel {
  static decode(json: any): Note;
  content: string;
  createdBy: ModelReference | User;
  privacy: NotePrivacy;
  event: ModelReference | Event;
}
export declare enum NotePrivacy {
  Private = "private",
  Public = "public"
}
export declare class Organisation extends MentornityModel {
  static decode(json: any): Organisation;
  domain: string;
  title: string;
  description: string;
  logoUrl: string;
  coverUrl: string;
  linkedInUrl: string;
  twitterUrl: string;
  facebookUrl: string;
  webSiteUrl: string;
  ref(): ModelReference;
}
export declare class OrganisationSubscriptionsSummary {
  groups: {
    subscribedCount: number;
    unsubscribedCount: number;
  };
  mentees: {
    subscribedCount: number;
    unsubscribedCount: number;
  };
  mentors: {
    subscribedCount: number;
    unsubscribedCount: number;
  };
}
export declare class OrganisationSummary {
  static decode(json: any): OrganisationSummary;
  _id: string;
  organisation: Organisation;
  metrics: OrganisationSummaryMetrics;
  completedSteps: any;
}
export declare class OrganisationSummaryMetrics {
  groupCount: number;
  menteeCount: number;
  mentorCount: number;
}
export declare class BaseFieldRule {
  type: 'condition' | 'group';
  rules?: BaseFieldRule[];
  operator?: 'and' | 'or';
  condition?: 'equal';
  key?: string;
  value?: string;
}
export declare class SubscriptionConfig {
  mentorVisibilityStatus: 'showAvailableMentors' | 'hideAvailableMentors';
  menteeSelectionLimit: number;
  menteeSubscriptionLimit: number;
  mentorsCanEndSubscription: boolean;
  processStartType: 'startOnSelection' | 'startOnApproval';
  rules: SubscriptionRule[];
}
export declare class SubscriptionRule extends BaseField {
  mentorField: string;
  menteeField: string;
  comparison: 'equal' | 'notEqual';
}
export declare class User extends MentornityModel {
  static decode(json: any): User;
  _roles: string[];
  bio: string;
  email: string;
  firstName: string;
  imageUrl: string;
  lastName: string;
  status: UserStatus;
  skills: string[];
  title: string;
  linkedInUrl: string;
  webSiteUrl: string;
  twitterUrl: string;
  facebookUrl: string;
  videoUrl: string;
  contactInfo: {
    email: string;
    phone: string;
    skype: string;
  };
  f: any;
  group?: Group;
  metadata?: Metadata;
  lastAvailability?: Availability;
  lastMeeting?: Event;
  lastSession?: any;
  mentorship?: Mentorship;
  subscriptions?: Subscription[];
  events?: Event[];
  constructor(data: any);
  ref(): ModelReference;
  getRolesInOrganisation(organisation: Organisation): {
    isAdmin: boolean;
    isMentee: boolean;
    isMentor: boolean;
  };
  isAdminOfAnyOrganisation(): boolean;
  getMetadataValue(id: string): any;
}
export declare enum UserStatus {
  Active = "active",
  Invited = "invited",
  NotInvited = "notInvited"
}
export declare class Settings extends MentornityModel {
  static decode(json: any): Settings;
  _id: string;
  language: string;
  timeZone: string;
  notification: {
    emailOnAvailabilityCreation: boolean;
    emailOnMeetingCancellation: boolean;
    emailOnMeetingCreation: boolean;
    emailOnMeetingNoteCreation: boolean;
    emailOnNewMessage: boolean;
  };
}
export declare class Subscription extends MentornityModel {
  static decode(json: any): Subscription;
  createdBy: User;
  organisation: Organisation | ModelReference;
  mentorship: Mentorship | ModelReference;
  subscribed: User | ModelReference;
  subscriber: User | Group | ModelReference;
  status: 'active' | 'completed' | 'rejected' | 'canceled' | 'requested';
  epoch: string;
  isFollowing: boolean;
}
export declare class FormModel extends MentornityModel {
  static decode(json: any): FormModel;
  title: string;
  description: string;
  target: FormTarget;
  type: FormType;
  status: FormStatus;
  form: FormData;
  organisation: ModelReference;
  ref(): ModelReference;
}
export declare class FormResponse extends MentornityModel {
  static decode(json: any): FormResponse;
  createdBy: User;
  assignedTo: User;
  relevantReference: User | Group | ModelReference;
  data: {
    [key: string]: any;
  };
  form: ModelReference | FormModel;
  type: string;
}
export declare enum FormType {
  Application = "application",
  Survey = "survey",
  PostSubscriptionFeedback = "postSubscriptionFeedback"
}
export declare enum FormTarget {
  All = "all",
  Mentee = "mentee",
  Mentor = "mentor"
}
export declare enum FormStatus {
  Published = "published",
  Unpublished = "unpublished"
}
export declare class ViewConfigWrapper extends MentornityModel {
  organisation: ModelReference;
  viewName: MentornityViewConfigViewName;
  createdBy: ModelReference | User;
  dvnAppViewConfig: DvnAppViewConfig;
  static decode(json: any): ViewConfigWrapper;
}
export declare enum MentornityViewConfigViewName {
  MentorApplicationForm = "mentor-application-form",
  MentorInfoForm = "mentor-info-form",
  MentorCardList = "mentor-card-list",
  MentorCardListDetail = "mentor-card-list-detail",
  MentorDetail = "mentor-detail",
  MentorDetailSummary = "mentor-detail-summary",
  MentorSelectionList = "mentor-selection-list",
  MentorSelectionListDetail = "mentor-selection-list-detail",
  MentorPairList = "mentor-pair-list",
  MentorPairDetail = "mentor-pair-detail",
  MenteeApplicationForm = "mentee-application-form",
  MenteeInfoForm = "mentee-info-form",
  MenteeCardList = "mentee-card-list",
  MenteeCardListDetail = "mentee-card-list-detail",
  MenteeDetail = "mentee-detail",
  MenteePairList = "mentee-pair-list",
  MenteePairDetail = "mentee-pair-detail",
  MenteePairDetailSummary = "mentee-pair-detail-summary"
}
export interface GetInvitation {
  accountType: string;
  createdAt: number;
  createdBy: object;
  firstName: string;
  invitee: User;
  issuedFor: string;
  language: string;
  lastName: string;
  organisation: Organisation;
  skills: string[];
  status: string;
  updatedAt: number;
  _id: string;
}
