@mattermost/types 11.1.0-0 → 11.1.0-1

package/lib/search.d.ts

@@ -0,0 +1,29 @@
+export type Search = {
+    terms: string;
+    isOrSearch: boolean;
+};
+export type SearchState = {
+    current: any;
+    results: string[];
+    fileResults: string[];
+    flagged: string[];
+    pinned: Record<string, string[]>;
+    isSearchingTerm: boolean;
+    isSearchGettingMore: boolean;
+    isLimitedResults: number;
+    matches: {
+        [x: string]: string[];
+    };
+    truncationInfo?: {
+        posts: number;
+        files: number;
+    };
+};
+export type SearchParameter = {
+    terms: string;
+    is_or_search: boolean;
+    time_zone_offset?: number;
+    page: number;
+    per_page: number;
+    include_deleted_channels: boolean;
+};

package/lib/sessions.d.ts

@@ -0,0 +1,15 @@
+import type { TeamMembership } from './teams';
+export type Session = {
+    id: string;
+    token: string;
+    create_at: number;
+    expires_at: number;
+    last_activity_at: number;
+    user_id: string;
+    device_id: string;
+    roles: string;
+    is_oauth: boolean;
+    props: Record<string, any>;
+    team_members: TeamMembership[];
+    local: boolean;
+};

package/lib/setup.d.ts

@@ -0,0 +1,4 @@
+export type CompleteOnboardingRequest = {
+    organization: string;
+    install_plugins: string[];
+};

package/lib/shared_channels.d.ts

@@ -0,0 +1,26 @@
+export type SharedChannelRemote = {
+    id: string;
+    channel_id: string;
+    creator_id: string;
+    create_at: number;
+    update_at: number;
+    delete_at: number;
+    is_invite_accepted: boolean;
+    is_invite_confirmed: boolean;
+    remote_id: string;
+    last_post_update_at: number;
+    last_post_id: string;
+    last_post_create_at: number;
+    last_post_create_id: string;
+};
+export type RemoteClusterInfo = {
+    name: string;
+    display_name: string;
+    create_at: number;
+    delete_at: number;
+    last_ping_at: number;
+};
+export type SharedChannelsState = {
+    remotes: Record<string, RemoteClusterInfo[]>;
+    remotesByRemoteId: Record<string, RemoteClusterInfo>;
+};

package/lib/store.d.ts

@@ -0,0 +1,97 @@
+import type { AdminState } from './admin';
+import type { AppsState } from './apps';
+import type { Bot } from './bots';
+import type { ChannelBookmarksState } from './channel_bookmarks';
+import type { ChannelCategoriesState } from './channel_categories';
+import type { ChannelsState } from './channels';
+import type { CloudState, CloudUsage } from './cloud';
+import type { ContentFlaggingState } from './content_flagging';
+import type { EmojisState } from './emojis';
+import type { FilesState } from './files';
+import type { GeneralState } from './general';
+import type { GroupsState } from './groups';
+import type { HostedCustomerState } from './hosted_customer';
+import type { IntegrationsState } from './integrations';
+import type { JobsState } from './jobs';
+import type { LimitsState } from './limits';
+import type { PostsState } from './posts';
+import type { PreferenceType } from './preferences';
+import type { AdminRequestsStatuses, ChannelsRequestsStatuses, FilesRequestsStatuses, GeneralRequestsStatuses, PostsRequestsStatuses, RolesRequestsStatuses, TeamsRequestsStatuses, UsersRequestsStatuses } from './requests';
+import type { Role } from './roles';
+import type { ScheduledPostsState } from './schedule_post';
+import type { SchemesState } from './schemes';
+import type { SearchState } from './search';
+import type { RemoteClusterInfo } from './shared_channels';
+import type { TeamsState } from './teams';
+import type { ThreadsState } from './threads';
+import type { Typing } from './typing';
+import type { UsersState } from './users';
+export type GlobalState = {
+    entities: {
+        general: GeneralState;
+        users: UsersState;
+        limits: LimitsState;
+        teams: TeamsState;
+        channels: ChannelsState;
+        channelBookmarks: ChannelBookmarksState;
+        posts: PostsState;
+        threads: ThreadsState;
+        bots: {
+            accounts: Record<string, Bot>;
+        };
+        preferences: {
+            myPreferences: {
+                [x: string]: PreferenceType;
+            };
+            userPreferences: {
+                [userID: string]: {
+                    [x: string]: PreferenceType;
+                };
+            };
+        };
+        admin: AdminState;
+        jobs: JobsState;
+        search: SearchState;
+        integrations: IntegrationsState;
+        files: FilesState;
+        emojis: EmojisState;
+        typing: Typing;
+        roles: {
+            roles: {
+                [x: string]: Role;
+            };
+            pending: Set<string>;
+        };
+        schemes: SchemesState;
+        groups: GroupsState;
+        channelCategories: ChannelCategoriesState;
+        apps: AppsState;
+        cloud: CloudState;
+        hostedCustomer: HostedCustomerState;
+        usage: CloudUsage;
+        scheduledPosts: ScheduledPostsState;
+        sharedChannels?: {
+            remotes?: Record<string, RemoteClusterInfo[]>;
+            remotesByRemoteId?: Record<string, RemoteClusterInfo>;
+        };
+        contentFlagging: ContentFlaggingState;
+    };
+    errors: any[];
+    requests: {
+        channels: ChannelsRequestsStatuses;
+        general: GeneralRequestsStatuses;
+        posts: PostsRequestsStatuses;
+        teams: TeamsRequestsStatuses;
+        users: UsersRequestsStatuses;
+        admin: AdminRequestsStatuses;
+        files: FilesRequestsStatuses;
+        roles: RolesRequestsStatuses;
+    };
+    websocket: {
+        connected: boolean;
+        lastConnectAt: number;
+        lastDisconnectAt: number;
+        connectionId: string;
+        serverHostname: string;
+    };
+};

package/lib/teams.d.ts

@@ -0,0 +1,99 @@
+import type { ServerError } from './errors';
+import type { UserProfile } from './users';
+import type { RelationOneToOne } from './utilities';
+export type TeamMembership = TeamUnread & {
+    user_id: string;
+    roles: string;
+    delete_at: number;
+    scheme_admin: boolean;
+    scheme_guest: boolean;
+    scheme_user: boolean;
+};
+export type TeamMemberWithError = {
+    member: TeamMembership;
+    user_id: string;
+    error: ServerError;
+};
+export type TeamType = 'O' | 'I';
+export type Team = {
+    id: string;
+    create_at: number;
+    update_at: number;
+    delete_at: number;
+    display_name: string;
+    name: string;
+    description: string;
+    email: string;
+    type: TeamType;
+    company_name: string;
+    allowed_domains: string;
+    invite_id: string;
+    allow_open_invite: boolean;
+    scheme_id: string;
+    group_constrained: boolean;
+    policy_id?: string | null;
+    last_team_icon_update?: number;
+};
+export type TeamsState = {
+    currentTeamId: string;
+    teams: Record<string, Team>;
+    myMembers: Record<string, TeamMembership>;
+    membersInTeam: RelationOneToOne<Team, RelationOneToOne<UserProfile, TeamMembership>>;
+    stats: RelationOneToOne<Team, TeamStats>;
+    groupsAssociatedToTeam: any;
+    totalCount: number;
+    contentFlaggingStatus: Record<Team['id'], boolean>;
+};
+export type TeamUnread = {
+    team_id: string;
+    /** The number of unread mentions in channels on this team, not including DMs and GMs */
+    mention_count: number;
+    /** The number of unread mentions in root posts in channels on this team, not including DMs and GMs */
+    mention_count_root: number;
+    /**
+     * The number of unread posts in channels on this team, not including DMs and GMs
+     *
+     * @remarks Note that this differs from ChannelMembership.msg_count and ChannelUnread.msg_count since it tracks
+     * unread posts instead of read posts.
+     */
+    msg_count: number;
+    /**
+     * The number of unread root posts in channels on this team, not including DMs and GMs
+     *
+     * @remarks Note that this differs from ChannelMember.msg_count_root and ChannelUnread.msg_count_root since it
+     * tracks unread posts instead of read posts.
+     */
+    msg_count_root: number;
+    thread_count?: number;
+    thread_mention_count?: number;
+    thread_urgent_mention_count?: number;
+};
+export type GetTeamMembersOpts = {
+    sort?: 'Username';
+    exclude_deleted_users?: boolean;
+};
+export type TeamsWithCount = {
+    teams: Team[];
+    total_count: number;
+};
+export type TeamStats = {
+    team_id: string;
+    total_member_count: number;
+    active_member_count: number;
+};
+export type TeamSearchOpts = PagedTeamSearchOpts | NotPagedTeamSearchOpts;
+export type PagedTeamSearchOpts = {
+    page: number;
+    per_page: number;
+} & NotPagedTeamSearchOpts;
+export type NotPagedTeamSearchOpts = {
+    allow_open_invite?: boolean;
+    group_constrained?: boolean;
+};
+export type TeamInviteWithError = {
+    email: string;
+    error: {
+        id: string;
+        message: string;
+    };
+};

package/lib/terms_of_service.d.ts

@@ -0,0 +1,6 @@
+export type TermsOfService = {
+    id: string;
+    create_at: number;
+    user_id: string;
+    text: string;
+};

package/lib/threads.d.ts

@@ -0,0 +1,63 @@
+import type { Channel } from './channels';
+import type { Post } from './posts';
+import type { Team } from './teams';
+import type { UserProfile } from './users';
+import type { IDMappedObjects, RelationOneToMany, RelationOneToOne } from './utilities';
+export declare enum UserThreadType {
+    Synthetic = "S"
+}
+export type UserThread = {
+    id: string;
+    reply_count: number;
+    last_reply_at: number;
+    last_viewed_at: number;
+    participants: Array<{
+        id: UserProfile['id'];
+    } | UserProfile>;
+    unread_replies: number;
+    unread_mentions: number;
+    is_following: boolean;
+    is_urgent?: boolean;
+    type?: UserThreadType;
+    /**
+     * only depend on channel_id and user_id for UserThread<>Channel/User mapping,
+     * use normalized post store/selectors as those are kept up-to-date in the store
+     */
+    post: {
+        channel_id: Channel['id'];
+        user_id: UserProfile['id'];
+    };
+};
+type SyntheticMissingKeys = 'unread_replies' | 'unread_mentions' | 'last_viewed_at';
+export type UserThreadSynthetic = Omit<UserThread, SyntheticMissingKeys> & {
+    type: UserThreadType.Synthetic;
+};
+export declare function threadIsSynthetic(thread: UserThread | UserThreadSynthetic): thread is UserThreadSynthetic;
+export type UserThreadWithPost = UserThread & {
+    post: Post;
+};
+export type UserThreadList = {
+    total: number;
+    total_unread_threads: number;
+    total_unread_mentions: number;
+    total_unread_urgent_mentions?: number;
+    threads: UserThreadWithPost[];
+};
+export type ThreadsState = {
+    threadsInTeam: RelationOneToMany<Team, UserThread>;
+    unreadThreadsInTeam: RelationOneToMany<Team, UserThread>;
+    threads: IDMappedObjects<UserThread>;
+    counts: RelationOneToOne<Team, {
+        total: number;
+        total_unread_threads: number;
+        total_unread_mentions: number;
+        total_unread_urgent_mentions?: number;
+    }>;
+    countsIncludingDirect: RelationOneToOne<Team, {
+        total: number;
+        total_unread_threads: number;
+        total_unread_mentions: number;
+        total_unread_urgent_mentions?: number;
+    }>;
+};
+export {};

package/lib/typing.d.ts

@@ -0,0 +1,5 @@
+export type Typing = {
+    [x: string]: {
+        [x: string]: number;
+    };
+};

package/lib/users.d.ts

@@ -0,0 +1,140 @@
+import type { Audit } from './audits';
+import type { Channel } from './channels';
+import type { Group } from './groups';
+import type { Session } from './sessions';
+import type { Team } from './teams';
+import type { IDMappedObjects, RelationOneToManyUnique, RelationOneToOne } from './utilities';
+export type UserNotifyProps = {
+    desktop: 'default' | 'all' | 'mention' | 'none';
+    desktop_sound: 'default' | 'true' | 'false';
+    calls_desktop_sound: 'true' | 'false';
+    email: 'true' | 'false';
+    mark_unread: 'all' | 'mention';
+    push: 'default' | 'all' | 'mention' | 'none';
+    push_status: 'ooo' | 'offline' | 'away' | 'dnd' | 'online';
+    comments: 'never' | 'root' | 'any';
+    first_name: 'true' | 'false';
+    channel: 'true' | 'false';
+    mention_keys: string;
+    highlight_keys: string;
+    desktop_notification_sound?: 'default' | 'Bing' | 'Crackle' | 'Down' | 'Hello' | 'Ripple' | 'Upstairs';
+    calls_notification_sound?: 'Dynamic' | 'Calm' | 'Urgent' | 'Cheerful';
+    desktop_threads?: 'default' | 'all' | 'mention' | 'none';
+    email_threads?: 'default' | 'all' | 'mention' | 'none';
+    push_threads?: 'default' | 'all' | 'mention' | 'none';
+    auto_responder_active?: 'true' | 'false';
+    auto_responder_message?: string;
+    calls_mobile_sound?: 'true' | 'false' | '';
+    calls_mobile_notification_sound?: 'Dynamic' | 'Calm' | 'Urgent' | 'Cheerful' | '';
+};
+export type UserProfile = {
+    id: string;
+    create_at: number;
+    update_at: number;
+    delete_at: number;
+    username: string;
+    password: string;
+    auth_data?: string;
+    auth_service: string;
+    email: string;
+    nickname: string;
+    first_name: string;
+    last_name: string;
+    position: string;
+    roles: string;
+    props: Record<string, string>;
+    notify_props: UserNotifyProps;
+    last_password_update: number;
+    last_picture_update: number;
+    locale: string;
+    timezone?: UserTimezone;
+    mfa_active: boolean;
+    last_activity_at: number;
+    is_bot: boolean;
+    bot_description: string;
+    terms_of_service_id: string;
+    terms_of_service_create_at: number;
+    remote_id?: string;
+    status?: string;
+    custom_profile_attributes?: Record<string, string | string[]>;
+    failed_attempts?: number;
+};
+export type UserProfileWithLastViewAt = UserProfile & {
+    last_viewed_at: number;
+};
+export type UsersState = {
+    currentUserId: string;
+    isManualStatus: RelationOneToOne<UserProfile, boolean>;
+    mySessions: Session[];
+    myAudits: Audit[];
+    profiles: IDMappedObjects<UserProfile>;
+    profilesInTeam: RelationOneToManyUnique<Team, UserProfile>;
+    profilesNotInTeam: RelationOneToManyUnique<Team, UserProfile>;
+    profilesWithoutTeam: Set<string>;
+    profilesInChannel: RelationOneToManyUnique<Channel, UserProfile>;
+    profilesNotInChannel: RelationOneToManyUnique<Channel, UserProfile>;
+    profilesInGroup: RelationOneToManyUnique<Group, UserProfile>;
+    profilesNotInGroup: RelationOneToManyUnique<Group, UserProfile>;
+    statuses: RelationOneToOne<UserProfile, string>;
+    stats: Partial<UsersStats>;
+    filteredStats: Partial<UsersStats>;
+    myUserAccessTokens: Record<string, UserAccessToken>;
+    lastActivity: RelationOneToOne<UserProfile, number>;
+    dndEndTimes: RelationOneToOne<UserProfile, number>;
+};
+export type UserTimezone = {
+    useAutomaticTimezone: boolean | string;
+    automaticTimezone: string;
+    manualTimezone: string;
+};
+export type UserStatus = {
+    user_id: string;
+    status: string;
+    manual?: boolean;
+    last_activity_at?: number;
+    active_channel?: string;
+    /**
+     * The time when a user's timed DND status will expire. Unlike other timestamps in the app, this is in seconds
+     * instead of milliseconds.
+     */
+    dnd_end_time?: number;
+};
+export declare enum CustomStatusDuration {
+    DONT_CLEAR = "",
+    THIRTY_MINUTES = "thirty_minutes",
+    ONE_HOUR = "one_hour",
+    FOUR_HOURS = "four_hours",
+    TODAY = "today",
+    THIS_WEEK = "this_week",
+    DATE_AND_TIME = "date_and_time",
+    CUSTOM_DATE_TIME = "custom_date_time"
+}
+export type UserCustomStatus = {
+    emoji: string;
+    text: string;
+    duration: CustomStatusDuration;
+    expires_at?: string;
+};
+export type UserAccessToken = {
+    id: string;
+    token?: string;
+    user_id: string;
+    description: string;
+    is_active: boolean;
+};
+export type UsersStats = {
+    total_users_count: number;
+};
+export type GetFilteredUsersStatsOpts = {
+    in_team?: string;
+    in_channel?: string;
+    include_deleted?: boolean;
+    include_bots?: boolean;
+    include_remote_users?: boolean;
+    roles?: string[];
+    channel_roles?: string[];
+    team_roles?: string[];
+};
+export type AuthChangeResponse = {
+    follow_link: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mattermost/types",
-  "version": "11.1.0-0",
+  "version": "11.1.0-1",
   "description": "Shared type definitions used by the Mattermost web app",
   "keywords": [
     "mattermost"