@atlaskit/teams-client 4.0.0

package/dist/types/services/legion-client/index.d.ts

@@ -0,0 +1,133 @@
+import { type InvitedUser, type LinkOrder, type NewTeamLink, type ReadMediaTokenResponse, type Team, type TeamLink, type TeamMembership, type TeamMembershipSettings, type TeamWithImageUrls, type TeamWithMemberships } from '../../types';
+import { type ExternalReference, type LinkedTeamsBulkResponse, type LinkedTeamsProfileDetails, type OrgScope, type SoftDeletedTeam, type TeamsPermissionFromApi } from '../../types/team';
+import { type UserInSiteUserbase } from '../../types/user';
+import { RestClient } from '../rest-client';
+import { type LegionLinkResponseV3, type LegionLinkResponseV4, type LegionPaginatedResponse, type LegionTeamAndGroupDifferenceResponse } from './types';
+export interface PaginationResult<T> {
+    entities: T[];
+}
+export interface OriginQuery {
+    /**
+     * @private
+     * @deprecated use getContext().cloudId instead
+     */
+    cloudId?: string;
+    product?: string | null;
+}
+/**
+ * @type AllTeamsQuery
+ * Query type for the getAllTeams API
+ * @property {string} orgId - Organization ID
+ * @property {string} cursor - Cursor to fetch the next page of results
+ * @property {number} limit - Number of teams to fetch
+ * @property {string} searchQuery - Search query to filter teams
+ * @property {string[]} memberAccountIds - List of member account IDs to filter teams
+ * @property {boolean} useDefaultSort - Whether to use the default sort order
+ * @property {boolean} showEmptyTeams - Whether to return empty teams in the search
+ */
+export interface AllTeamsQuery {
+    /**
+     * @private
+     * @deprecated use getContext().orgId instead
+     */
+    orgId: string;
+    cursor?: string;
+    limit?: number;
+    searchQuery?: string;
+    memberAccountIds?: string[];
+    useDefaultSort?: boolean;
+    showEmptyTeams?: boolean;
+}
+/**
+ * @type AllTeamsResponse
+ * Response type for the getAllTeams API
+ * @property {TeamWithMemberships[]} teams - List of teams
+ * @property {string} cursor - Cursor to fetch the next page of results
+ * @property {Error} error - Error object if the API call fails
+ */
+export interface AllTeamsResponse {
+    teams: TeamWithMemberships[];
+    cursor: string;
+    error?: Error;
+}
+/**
+ * @type AllTeamsPayload
+ * Payload type for the getAllTeams API
+ * @property {TeamWithMemberships[]} entities - List of teams
+ * @property {string} cursor - Cursor to fetch the next page of results
+ */
+export interface AllTeamsPayload {
+    entities: TeamWithMemberships[];
+    cursor: string;
+}
+export interface LegionClient {
+    getTeamById(teamId: string): Promise<TeamWithImageUrls>;
+    updateTeamById(teamId: string, data: Partial<Team>): Promise<TeamWithImageUrls>;
+    getAllTeams(allTeamsQuery: AllTeamsQuery): Promise<AllTeamsResponse>;
+    inviteUsersToTeam(teamId: string, users: InvitedUser[], originQuery: OriginQuery): Promise<TeamMembership[]>;
+    getMyTeamMembership(teamId: string): Promise<TeamMembership>;
+    getTeamLinksByTeamId(teamId: string): Promise<{
+        entities: TeamLink[];
+    }>;
+    createTeamLink(teamId: string, link: NewTeamLink): Promise<TeamLink>;
+    updateTeamLink(teamId: string, linkId: string, newLink: NewTeamLink): Promise<TeamLink>;
+    deleteTeamLink(teamId: string, linkId: string): Promise<void>;
+    reorderTeamLink(teamId: string, linkId: string, newPosition: number): Promise<LinkOrder>;
+    acceptTeamInvitation(teamId: string): Promise<TeamMembership>;
+    declineTeamInvitation(teamId: string): Promise<void>;
+    selfJoinTeam(teamId: string, originQuery: OriginQuery): Promise<TeamMembership>;
+    cancelJoinRequest(teamId: string): Promise<void>;
+    acceptJoinRequest(teamId: string, memberId: string): Promise<TeamMembership>;
+    declineJoinRequest(teamId: string, memberId: string): Promise<void>;
+    deleteTeamMembership(teamId: string, memberId: string): Promise<TeamMembership>;
+    revokeTeamInvite(teamId: string, memberId: string): Promise<TeamMembership>;
+    deleteTeam(teamId: string): Promise<void>;
+    isSingleFullMemberTeam(teamId: string): Promise<boolean>;
+    createTeam(displayName: string, originQuery: OriginQuery, members?: string[], membershipSettings?: TeamMembershipSettings): Promise<Team>;
+    createExternalTeam(description: string, externalReference: ExternalReference, teamName?: string, siteId?: string): Promise<Team>;
+    retrieveBrowseUserPermission(product: string): Promise<{
+        canSearchUsers: boolean;
+    }>;
+    getLinkedTeamsBulk(groupIds: string[]): Promise<LinkedTeamsBulkResponse>;
+    getTeamProfileDetails(teamId: string): Promise<LinkedTeamsProfileDetails>;
+    getOrgScope(): Promise<OrgScope>;
+    getPermissions(): Promise<TeamsPermissionFromApi>;
+    restoreTeamToSyncedGroup(teamId: string, externalReference: ExternalReference): Promise<void>;
+}
+/**
+ * REST Client to make calls to Legion.
+ *
+ * Redirects to the instance login screen when a response returns a 401.
+ * It should probably redirect to Aa, but this is what the existing clients
+ * do so I'm going to follow suite.
+ */
+export declare class LegionClient extends RestClient implements LegionClient {
+    private serviceUrlRoot;
+    constructor(serviceUrl: string);
+    setRootUrl(url: string): void;
+    getOrgEligibilityForManagedTeams(): Promise<{
+        isEligible: boolean;
+    }>;
+    getTeamAndGroupDiff(teamId: string, externalReference: ExternalReference): Promise<LegionTeamAndGroupDifferenceResponse>;
+    linkExistingTeamToGroup(teamId: string, externalReference: ExternalReference): Promise<void>;
+    getWriteMediaToken(): Promise<ReadMediaTokenResponse>;
+    getSoftDeletedTeamById(teamId: string): Promise<SoftDeletedTeam>;
+    /**
+     * Shoud only be used within Teams (P&T) packages
+     */
+    getUserInSiteUserBase(userId: string): Promise<UserInSiteUserbase>;
+    trimTeamARI(teamId?: string): string;
+    private constructProductOriginParams;
+    private mapTeamResponseV4ToTeam;
+    private mapTeamCreateResponseV4ToTeam;
+    private mapTeamSearchResponseV4ToTeamWithMembership;
+    mapLegionTeamLinksResponseV3ToTeamLinkResponse(response: LegionPaginatedResponse<LegionLinkResponseV3>): {
+        entities: TeamLink[];
+    };
+    mapLegionTeamLinksResponseV4ToTeamLinkResponse(response: LegionPaginatedResponse<LegionLinkResponseV4>): {
+        entities: TeamLink[];
+    };
+    mapLegionTeamLinkResponseV3ToTeamLink(legionLinkResponseV3: LegionLinkResponseV3): TeamLink;
+    mapLegionTeamLinkResponseV4ToTeamLink(legionLinkResponseV4: LegionLinkResponseV4): TeamLink;
+}
+export declare const defaultLegionClient: LegionClient;

package/dist/types/services/legion-client/types.d.ts

@@ -0,0 +1,107 @@
+import { type TeamMembership } from '../../types/membership';
+import { type ScopeMode, type TeamDiscoverability, type TeamMembershipSettings, type TeamPermission, type TeamRestriction, type TeamState } from '../../types/team';
+export interface LegionTeamImagesResponse {
+    smallHeaderImageUrl: string;
+    largeHeaderImageUrl: string;
+    smallAvatarImageUrl: string;
+    largeAvatarImageUrl: string;
+}
+export interface LegionTeamMembershipResponse {
+    membership: {
+        members: TeamMembership[];
+        errors: string[];
+    };
+}
+export interface LegionTeamBaseResponseV3 {
+    id: string;
+    displayName: string;
+    description: string;
+    state: TeamState;
+    membershipSettings: TeamMembershipSettings;
+    discoverable?: TeamDiscoverability;
+    organizationId?: string;
+    restriction: TeamRestriction;
+    creatorId?: string;
+    creatorDomain?: string;
+    permission?: TeamPermission;
+}
+export type LegionTeamGetResponseV3 = LegionTeamBaseResponseV3 & LegionTeamImagesResponse;
+export type LegionTeamCreateResponseV3 = LegionTeamBaseResponseV3 & LegionTeamMembershipResponse;
+export interface LegionTeamBaseResponseV4 {
+    id: string;
+    displayName: string;
+    description: string;
+    state: TeamState;
+    membershipSettings: TeamMembershipSettings;
+    organizationId: string;
+    creatorId?: string;
+    permission?: TeamPermission;
+    scopeMode: ScopeMode;
+    isVerified?: boolean;
+}
+export type LegionTeamGetResponseV4 = LegionTeamBaseResponseV4 & Required<LegionTeamImagesResponse>;
+export type LegionTeamCreateResponseV4 = LegionTeamBaseResponseV4 & Required<LegionTeamMembershipResponse>;
+export type LegionTeamAndGroupDifferenceResponse = {
+    displayNameChange: {
+        from: string;
+        to: string;
+    } | null;
+    membersToAdd: {
+        count: number;
+        memberIds: string[];
+    };
+    membersToRemove: {
+        count: number;
+        memberIds: string[];
+    };
+};
+export interface LegionTeamSearchResponseV3 {
+    id: string;
+    displayName: string;
+    description: string;
+    state: TeamState;
+    membershipSettings: TeamMembershipSettings;
+    discoverable?: TeamDiscoverability;
+    organizationId?: string;
+    restriction: TeamRestriction;
+    smallHeaderImageUrl: string;
+    largeHeaderImageUrl: string;
+    smallAvatarImageUrl: string;
+    largeAvatarImageUrl: string;
+    memberCount: number;
+    includesYou: boolean;
+}
+export interface LegionTeamSearchResponseV4 {
+    id: string;
+    displayName: string;
+    description: string;
+    state: TeamState;
+    membershipSettings: TeamMembershipSettings;
+    organizationId?: string;
+    smallHeaderImageUrl: string;
+    largeHeaderImageUrl: string;
+    smallAvatarImageUrl: string;
+    largeAvatarImageUrl: string;
+    memberCount: number;
+    includesYou: boolean;
+    isVerified?: boolean;
+}
+export interface LegionPaginatedResponse<T> {
+    entities: T[];
+    cursor: string;
+}
+export interface LegionLinkResponseV3 {
+    contentTitle: string;
+    description: string;
+    linkUri: string;
+    creationTime?: string;
+    linkId: string;
+    teamId?: string;
+}
+export interface LegionLinkResponseV4 {
+    contentTitle: string;
+    description: string;
+    linkUri: string;
+    linkId: string;
+    teamId?: string;
+}

package/dist/types/services/main.d.ts

@@ -0,0 +1,316 @@
+import { type MembershipState, type TeamMembership } from '../types';
+import { aggClient } from './agg-client';
+import { type AGGPageInfoVariables, type ResultWithPageInfo } from './agg-client/types';
+import collaborationGraphClient from './collaborationgraph-client';
+import { directoryClient } from './directory-client';
+import identityClient from './identity-client';
+import invitationsClient from './invitations-client';
+import { defaultLegionClient } from './legion-client';
+import mutabilityClient from './mutability-client';
+import objectResolverClient from './object-resolver-client';
+import permsClient from './perms-client';
+import publicApiClient from './public-api-client';
+import teamsInSlackClient from './teams-in-slack-client';
+import { type ClientContextProps } from './types';
+import userPreferencesClient from './user-preferences-client';
+/**
+ * This solves error TS1055:
+ * Type 'ReturnType' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value
+ */
+type AwaitedReturn<T extends (...args: any) => any> = Awaited<ReturnType<T>>;
+/**
+ * The Teams Client is an used for fetching data related to Atlas teams.
+ * It is an abstraction over the various clients that are used to fetch data related to teams.
+ * Find out more about the APIs here - [https://developer.atlassian.com/platform/teams-internal/](https://developer.atlassian.com/platform/teams-internal/)
+ */
+export declare class TeamsClient {
+    private readonly _aggClient;
+    private readonly _directoryClient;
+    private readonly _legionClient;
+    private readonly _mutabilityClient;
+    private readonly _permsClient;
+    private readonly _publicApiClient;
+    private readonly _invitationsClient;
+    private readonly _userPreferencesClient;
+    private readonly _objectResolverClient;
+    private readonly _teamsInSlackClient;
+    private readonly _collaborationGraphClient;
+    private readonly _identityClient;
+    constructor(
+    /**
+     * @param {ClientContextProps} context - Context including CloudId & OrgId to be used for all requests
+     */
+    context?: ClientContextProps);
+    private measurePerformance;
+    /**
+     * Sets the base URL to be used in the client requests
+     * @param {string} baseUrl - The new base URL
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Sets context including CloudId & OrgId to be used for all requests
+     */
+    setContext(context: ClientContextProps): void;
+    /**
+     * @private
+     * @deprecated use setBaseUrl instead
+     */
+    setDirectoryBaseUrl(baseUrl: string): void;
+    /**
+     * Fetches Browse user settings
+     */
+    querySettings(cloudId?: string, product?: string): Promise<{
+        ['internal.browse-users-allowed']: boolean;
+    }>;
+    /**
+     * This will return all of the teams-related permissions that your user has for the org and site in the client context.
+     */
+    getPermissions(): Promise<AwaitedReturn<typeof defaultLegionClient.getPermissions>>;
+    /**
+     * Fetches feature flags from Directory
+     * @deprecated As part of decommisioning pf-directoy
+     */
+    queryFeatureFlags(...args: Parameters<typeof directoryClient.queryFeatureFlags>): Promise<AwaitedReturn<typeof directoryClient.queryFeatureFlags>>;
+    /**
+     * Get user information of members of a team, paginated
+     * @param {string} teamId
+     * @returns {Promise}
+     */
+    queryTeamMemberships(teamId: string, membershipState?: MembershipState[], pageInfo?: AGGPageInfoVariables): Promise<ResultWithPageInfo<TeamMembership>>;
+    /**
+     * Get user information given an user id
+     * @param {string} userId
+     * @returns {Promise}
+     */
+    queryAGGUser(userId: string): Promise<AwaitedReturn<typeof aggClient.queryAGGUser>>;
+    /**
+     * Get user information of a member of a team
+     * @param {string} userId
+     * @returns {Promise<CloudUser>}
+     */
+    queryUser(...args: Parameters<typeof directoryClient.queryUser>): Promise<AwaitedReturn<typeof directoryClient.queryUser>>;
+    setLegionRootUrl(url: string): void;
+    /**
+     *
+     * @param teamId
+     * @returns {Promise<TeamWithImageUrls>}
+     */
+    getTeamById(teamId: string): Promise<AwaitedReturn<typeof defaultLegionClient.getTeamById>>;
+    /**
+     * Search teams based on query
+     */
+    getAllTeams(...args: Parameters<typeof defaultLegionClient.getAllTeams>): Promise<AwaitedReturn<typeof defaultLegionClient.getAllTeams>>;
+    /**
+     * Update team details
+     */
+    updateTeamById(...args: Parameters<typeof defaultLegionClient.updateTeamById>): Promise<AwaitedReturn<typeof defaultLegionClient.updateTeamById>>;
+    /**
+     * @private
+     * @deprecated use addUsersToTeam instead
+     */
+    inviteUsersToTeam(...args: Parameters<typeof defaultLegionClient.inviteUsersToTeam>): Promise<AwaitedReturn<typeof defaultLegionClient.inviteUsersToTeam>>;
+    /**
+     * Get the current user's team membership
+     */
+    getMyTeamMembership(...args: Parameters<typeof defaultLegionClient.getMyTeamMembership>): Promise<AwaitedReturn<typeof defaultLegionClient.getMyTeamMembership>>;
+    /**
+     * Get a teams "Links"
+     */
+    getTeamLinksByTeamId(teamId: string): Promise<AwaitedReturn<typeof defaultLegionClient.getTeamLinksByTeamId>>;
+    /**
+     * Create a team link
+     */
+    createTeamLink(...args: Parameters<typeof defaultLegionClient.createTeamLink>): Promise<AwaitedReturn<typeof defaultLegionClient.createTeamLink>>;
+    /**
+     * Update a team link
+     */
+    updateTeamLink(...args: Parameters<typeof defaultLegionClient.updateTeamLink>): Promise<AwaitedReturn<typeof defaultLegionClient.updateTeamLink>>;
+    /**
+     * Delete a team link
+     */
+    deleteTeamLink(...args: Parameters<typeof defaultLegionClient.deleteTeamLink>): Promise<void>;
+    /**
+     * Reorder a team link
+     */
+    reorderTeamLink(...args: Parameters<typeof defaultLegionClient.reorderTeamLink>): Promise<AwaitedReturn<typeof defaultLegionClient.reorderTeamLink>>;
+    /**
+     * Get org's eligibility for managed teams
+     */
+    getOrgEligibilityForManagedTeams(): Promise<AwaitedReturn<typeof defaultLegionClient.getOrgEligibilityForManagedTeams>>;
+    /**
+     * @deprecated Invitation status no longer exists
+     * Accept a team invitation
+     */
+    acceptTeamInvitation(...args: Parameters<typeof defaultLegionClient.acceptTeamInvitation>): Promise<AwaitedReturn<typeof defaultLegionClient.acceptTeamInvitation>>;
+    /**
+     * @deprecated Invitation status no longer exists
+     * Decline a team invitation
+     */
+    declineTeamInvitation(...args: Parameters<typeof defaultLegionClient.declineTeamInvitation>): Promise<void>;
+    /**
+     * Add current user to a team
+     */
+    selfJoinTeam(...args: Parameters<typeof defaultLegionClient.selfJoinTeam>): Promise<AwaitedReturn<typeof defaultLegionClient.selfJoinTeam>>;
+    /**
+     * Cancel a join request to a private team
+     */
+    cancelJoinRequest(teamId: string): Promise<void>;
+    /**
+     * Accept a join request to a private team
+     */
+    acceptJoinRequest(...args: Parameters<typeof defaultLegionClient.acceptJoinRequest>): Promise<AwaitedReturn<typeof defaultLegionClient.acceptJoinRequest>>;
+    /**
+     * Decline a join request to a private team
+     */
+    declineJoinRequest(...args: Parameters<typeof defaultLegionClient.declineJoinRequest>): Promise<void>;
+    /**
+     * @deprecated use removeTeamMemberships instead
+     */
+    deleteTeamMembership(...args: Parameters<typeof defaultLegionClient.deleteTeamMembership>): Promise<AwaitedReturn<typeof defaultLegionClient.deleteTeamMembership>>;
+    /**
+     * @deprecated INVITED status has been deprecated
+     */
+    revokeTeamInvite(...args: Parameters<typeof defaultLegionClient.revokeTeamInvite>): Promise<AwaitedReturn<typeof defaultLegionClient.revokeTeamInvite>>;
+    /**
+     * Delete a team
+     */
+    deleteTeam(teamId: string): Promise<void>;
+    /**
+     * @private
+     * @deprecated should be other means to solve this issue
+     */
+    isSingleFullMemberTeam(teamId: string): Promise<boolean>;
+    /**
+     * Create a team
+     */
+    createTeam(...args: Parameters<typeof defaultLegionClient.createTeam>): Promise<AwaitedReturn<typeof defaultLegionClient.createTeam>>;
+    /**
+     * Create a external team
+     * @param {string} groupDescription - The description of the group, which will be used as the team description. The group name will be fetched from the identity service, so it does not need to be provided.
+     * @param {ExternalReference} externalReference
+     */
+    createExternalTeam(...args: Parameters<typeof defaultLegionClient.createExternalTeam>): Promise<AwaitedReturn<typeof defaultLegionClient.createExternalTeam>>;
+    /**
+     * Get linked teams for a groups in bulk
+     * @param {string} groupIds - The group ids to fetch linked teams for
+     */
+    getLinkedTeamsBulk(...args: Parameters<typeof defaultLegionClient.getLinkedTeamsBulk>): Promise<AwaitedReturn<typeof defaultLegionClient.getLinkedTeamsBulk>>;
+    /**
+     * Get Org scope
+     */
+    getOrgScope(...args: Parameters<typeof defaultLegionClient.getOrgScope>): Promise<AwaitedReturn<typeof defaultLegionClient.getOrgScope>>;
+    /**
+     * Restore soft-deleted team and sync to group
+     */
+    restoreTeamToSyncedGroup(...args: Parameters<typeof defaultLegionClient.restoreTeamToSyncedGroup>): Promise<void>;
+    /**
+     * Get the difference between a team and a group
+     * @param teamId
+     * @param {ExternalReference} externalReference
+     * @returns {Promise<TeamAndGroupDifference>}
+     */
+    getTeamAndGroupDiff(...args: Parameters<typeof defaultLegionClient.getTeamAndGroupDiff>): Promise<AwaitedReturn<typeof defaultLegionClient.getTeamAndGroupDiff>>;
+    /**
+     * Link an existing team to a group
+     * @param teamId
+     * @param {ExternalReference} externalReference
+     */
+    linkExistingTeamToGroup(...args: Parameters<typeof defaultLegionClient.linkExistingTeamToGroup>): Promise<AwaitedReturn<typeof defaultLegionClient.linkExistingTeamToGroup>>;
+    /**
+     *
+     * @param teamId
+     * @returns {Promise<LinkedTeamsProfileDetails>}
+     */
+    getTeamProfileDetailsByTeamId(...args: Parameters<typeof defaultLegionClient.getTeamProfileDetails>): Promise<AwaitedReturn<typeof defaultLegionClient.getTeamProfileDetails>>;
+    /**
+     *
+     * @param teamId
+     * @returns {Promise<SoftDeletedTeam>}
+     */
+    getSoftDeletdTeamById(teamId: string): Promise<AwaitedReturn<typeof defaultLegionClient.getSoftDeletedTeamById>>;
+    /**
+     * Shoud only be used within Teams (P&T) packages
+     * @param userId
+     * @returns {Promise<SoftDeletedTeam>}
+     */
+    getUserInSiteUserBase(userId: string): Promise<AwaitedReturn<typeof defaultLegionClient.getUserInSiteUserBase>>;
+    trimTeamARI(teamId?: string): string;
+    /**
+     * Get user profile with mutability constraints
+     */
+    getProfileWithMutability(...args: Parameters<typeof mutabilityClient.getProfileWithMutability>): Promise<AwaitedReturn<typeof mutabilityClient.getProfileWithMutability>>;
+    /**
+     * Is the current user a site admin
+     */
+    getIsSiteAdmin(...args: Parameters<typeof permsClient.getIsSiteAdmin>): Promise<AwaitedReturn<typeof permsClient.getIsSiteAdmin>>;
+    /**
+     * Add users to a team
+     */
+    addUsersToTeam(...args: Parameters<typeof publicApiClient.addUsersToTeam>): Promise<AwaitedReturn<typeof publicApiClient.addUsersToTeam>>;
+    /**
+     * Remove users from a team
+     */
+    removeTeamMemberships(...args: Parameters<typeof publicApiClient.removeTeamMemberships>): Promise<AwaitedReturn<typeof publicApiClient.removeTeamMemberships>>;
+    /**
+     * Restore a deleted team
+     */
+    restoreTeam(...args: Parameters<typeof publicApiClient.restoreTeam>): Promise<AwaitedReturn<typeof publicApiClient.restoreTeam>>;
+    getRecommendedProducts(...args: Parameters<typeof invitationsClient.getProductRecommendations>): Promise<AwaitedReturn<typeof invitationsClient.getProductRecommendations>>;
+    joinOrRequestDefaultAccessToProductsBulk(...args: Parameters<typeof invitationsClient.joinOrRequestDefaultAccessToProductsBulk>): Promise<AwaitedReturn<typeof invitationsClient.joinOrRequestDefaultAccessToProductsBulk>>;
+    /**
+     * Get token to upload media for a team
+     */
+    getWriteTeamMediaToken(): Promise<AwaitedReturn<typeof userPreferencesClient.getReadMediaToken>>;
+    /**
+     * Get token to read media for a user
+     */
+    getReadMediaToken(...args: Parameters<typeof userPreferencesClient.getReadMediaToken>): Promise<AwaitedReturn<typeof userPreferencesClient.getReadMediaToken>>;
+    /**
+     * Get token to upload media for a user
+     */
+    getWriteUserMediaToken(): Promise<AwaitedReturn<typeof userPreferencesClient.getReadMediaToken>>;
+    /**
+     * Update header image for a user
+     */
+    updateUserHeaderImage(headerImageId: string | null): Promise<AwaitedReturn<typeof userPreferencesClient.updateUserHeaderImage>>;
+    /**
+     * Fetch user containers from collboration graph
+     */
+    getUserContainers(...args: Parameters<typeof collaborationGraphClient.getUserContainers>): Promise<AwaitedReturn<typeof collaborationGraphClient.getUserContainers>>;
+    /**
+     * Fetch mutatability of external managed user fields
+     */
+    getUserManageConfig(...args: Parameters<typeof identityClient.getUserManageConfig>): Promise<AwaitedReturn<typeof identityClient.getUserManageConfig>>;
+    /**
+     * Fetch user avatar uploaded status
+     */
+    getMyAvatarUploadedStatus(...args: Parameters<typeof identityClient.getMyAvatarUploadedStatus>): Promise<AwaitedReturn<typeof identityClient.getMyAvatarUploadedStatus>>;
+    /**
+     * Delete user avatar
+     */
+    deleteAvatar(...args: Parameters<typeof identityClient.deleteAvatar>): Promise<AwaitedReturn<typeof identityClient.deleteAvatar>>;
+    fetchUserAvatarInfo(...args: Parameters<typeof identityClient.fetchUserAvatarInfo>): Promise<AwaitedReturn<typeof identityClient.fetchUserAvatarInfo>>;
+    /**
+     * Fetch Team link icons
+     */
+    getTeamLinkIcons(...args: Parameters<typeof objectResolverClient.getTeamLinkIcons>): Promise<AwaitedReturn<typeof objectResolverClient.getTeamLinkIcons>>;
+    /**
+     * Fetch team in slack details
+     */
+    getTeamInSlack(...args: Parameters<typeof teamsInSlackClient.getTeamInSlack>): Promise<AwaitedReturn<typeof teamsInSlackClient.getTeamInSlack>>;
+    /**
+     * Delete team in slack
+     */
+    disconnectTeamInSlack(...args: Parameters<typeof teamsInSlackClient.disconnectTeamInSlack>): Promise<AwaitedReturn<typeof teamsInSlackClient.disconnectTeamInSlack>>;
+    /**
+     * Update team in slack
+     */
+    updateTeamInSlack(...args: Parameters<typeof teamsInSlackClient.updateTeamInSlack>): Promise<AwaitedReturn<typeof teamsInSlackClient.updateTeamInSlack>>;
+    /**
+     * Update user details
+     */
+    updateUser(...args: Parameters<typeof identityClient.updateUser>): Promise<AwaitedReturn<typeof identityClient.updateUser>>;
+    updateUserAvatar(...args: Parameters<typeof identityClient.updateUserAvatar>): Promise<AwaitedReturn<typeof identityClient.updateUserAvatar>>;
+}
+export declare const teamsClient: TeamsClient;
+export {};

package/dist/types/services/mutability-client/index.d.ts

@@ -0,0 +1,8 @@
+import { RestClient } from '../rest-client';
+import { type MutabilityConstraint } from './types';
+export declare class MutabilityClient extends RestClient {
+    constructor(config?: {});
+    getProfileWithMutability(userId: string): Promise<MutabilityConstraint[]>;
+}
+declare const _default: MutabilityClient;
+export default _default;

package/dist/types/services/mutability-client/types.d.ts

@@ -0,0 +1,5 @@
+export type Reason = 'managed' | 'ext.dir.scim' | 'ext.dir.google';
+export interface MutabilityConstraint {
+    field: string;
+    reason: Reason;
+}

package/dist/types/services/object-resolver-client/index.d.ts

@@ -0,0 +1,8 @@
+import { RestClient } from '../rest-client';
+import { type LinkIconData } from './types';
+export declare class ObjectResolverClient extends RestClient {
+    constructor(config?: {});
+    getTeamLinkIcons(teamLinkUrls: string[]): Promise<LinkIconData[]>;
+}
+declare const _default: ObjectResolverClient;
+export default _default;

package/dist/types/services/object-resolver-client/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * This type matches the props for the TeamLinkIcon component in embeddable-directory
+ */
+export type LinkIconData = {
+    linkUrl: string;
+    iconUrl: string | undefined;
+    productName: string;
+};
+export interface RawLinkData {
+    url: string;
+    generator: {
+        name: string;
+        icon?: string | {
+            url: string;
+        };
+    };
+}
+/**
+ * These names match the Provider Name in the JSON-LD response from respective resolvers
+ */
+export declare enum ProviderNames {
+    CONFLUENCE = "Confluence",
+    JIRA = "Jira"
+}
+export interface IconItemSuccess {
+    body: {
+        data: RawLinkData;
+    };
+    status: number;
+}
+export interface IconItemFailure {
+    error: {
+        type: string;
+        message: string;
+        status: number;
+    };
+    status: number;
+}

package/dist/types/services/object-resolver-client/utils.d.ts

@@ -0,0 +1,18 @@
+import { type IconItemFailure, type IconItemSuccess, type LinkIconData, type RawLinkData } from './types';
+/**
+ * Formats data into LinkIconData with appropriate Jira/Confluence favicon urls.
+ * Undefined icons remain undefined.
+ * Exported for testing purposes.
+ *
+ * Confluence favicon extension: /wiki/favicon.ico
+ * Jira favicon extension: /favicon.ico
+ *
+ * @param jsonLd - raw JSON-LD data for an individual link
+ */
+export declare const formatLinkIconData: (jsonLd: RawLinkData) => LinkIconData;
+/**
+ * Converts batched list of json-ld responses into list of formatted LinkIconData { url, icon_url }
+ *
+ * @param batchResp - list of json-ld responses { body, status }
+ */
+export declare const transformIconData: (batchResp: (IconItemSuccess | IconItemFailure)[]) => LinkIconData[];

package/dist/types/services/perms-client/index.d.ts

@@ -0,0 +1,16 @@
+import { RestClient } from '../rest-client';
+export declare class PermsClient extends RestClient {
+    getIsSiteAdmin(
+    /**
+     * @private
+     * @deprecated don't need to pass param, value is taken from `this.getCloudId()` instead
+     */
+    cloudId?: string): Promise<boolean>;
+}
+/**
+ * REST Client to make calls to resources on the activity service.
+ *
+ * @type {RestClient}
+ */
+declare const _default: PermsClient;
+export default _default;