@atlaskit/teams-client 4.0.0

package/dist/esm/services/user-preferences-client/index.js

@@ -0,0 +1,91 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+var buildGetReadTokenURL = function buildGetReadTokenURL(accountId) {
+  return "/api/user-image/".concat(accountId, "/header-image/read");
+};
+export var UserPreferencesClient = /*#__PURE__*/function (_RestClient) {
+  function UserPreferencesClient() {
+    _classCallCheck(this, UserPreferencesClient);
+    return _callSuper(this, UserPreferencesClient, arguments);
+  }
+  _inherits(UserPreferencesClient, _RestClient);
+  return _createClass(UserPreferencesClient, [{
+    key: "getReadMediaToken",
+    value: function () {
+      var _getReadMediaToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(accountId) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.getResource(buildGetReadTokenURL(accountId)).then(function (response) {
+                return response;
+              }));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getReadMediaToken(_x) {
+        return _getReadMediaToken.apply(this, arguments);
+      }
+      return getReadMediaToken;
+    }()
+  }, {
+    key: "getWriteMediaToken",
+    value: function () {
+      var _getWriteMediaToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", this.getResource('/api/user-image/header-image/write').then(function (response) {
+                return response;
+              }));
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getWriteMediaToken() {
+        return _getWriteMediaToken.apply(this, arguments);
+      }
+      return getWriteMediaToken;
+    }()
+  }, {
+    key: "updateUserHeaderImage",
+    value: function () {
+      var _updateUserHeaderImage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(headerImageId) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.putResource('/api/user-image/self/header-image', {
+                headerImageId: headerImageId
+              });
+            case 2:
+              return _context3.abrupt("return", _context3.sent);
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function updateUserHeaderImage(_x2) {
+        return _updateUserHeaderImage.apply(this, arguments);
+      }
+      return updateUserHeaderImage;
+    }()
+  }]);
+}(RestClient);
+export default new UserPreferencesClient({
+  serviceUrl: DEFAULT_CONFIG.stargateRoot
+});

package/dist/esm/types/index.js

@@ -0,0 +1,2 @@
+export { isEditableUserField } from './user';
+export { isResultWithPageInfo } from '../services/agg-client/types';

package/dist/esm/types/links.js

@@ -0,0 +1,16 @@
+/**
+ * Used to synchronise these field names to forms used to create/edit links e.g. TeamLinkForm
+ */
+export var LINK_FIELDS = {
+  CONTENT_TITLE: 'contentTitle',
+  DESCRIPTION: 'description',
+  LINK_URI: 'linkUri'
+};
+
+/**
+ * Type for uncreated team links. These don't have link IDs
+ */
+
+/**
+ * Type for order of team links.
+ */

package/dist/esm/types/membership.js

@@ -0,0 +1,17 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+/**
+ * @private
+ * @deprecated INVITED is deprecated
+ */
+
+/**
+ * @param membershipId - The team IDZ
+ */
+
+// Currently an agent is just a user, they may diverge if we need more agent specific fields
+
+// The minimal user required to invited someone
+
+export function isTeamMembershipWithUser(membership) {
+  return _typeof(membership.user) === 'object';
+}

package/dist/esm/types/team.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/user.js

@@ -0,0 +1,4 @@
+var EditableUserFieldList = ['title', 'department', 'companyName', 'location', 'phoneNumber', 'fullName', 'nickname', 'locale', 'email'];
+export var isEditableUserField = function isEditableUserField(key) {
+  return EditableUserFieldList.includes(key);
+};

package/dist/types/common/types.d.ts

@@ -0,0 +1,4 @@
+export declare const USER_ARI_PREFIX: "ari:cloud:identity::user/";
+export type UserARI = `${typeof USER_ARI_PREFIX}${string}`;
+export declare const TEAM_ARI_PREFIX: "ari:cloud:identity::team/";
+export type TeamARI = `${typeof TEAM_ARI_PREFIX}${string}`;

package/dist/types/common/utils/ari.d.ts

@@ -0,0 +1,7 @@
+import { type TeamARI, type UserARI } from '../types';
+export declare const isUserARI: (ari: string) => ari is `ari:cloud:identity::user/${string}`;
+export declare const toUserId: (ari: UserARI | string) => string;
+export declare const toUserARI: (userId: string) => UserARI;
+export declare const isTeamARI: (ari: string) => ari is `ari:cloud:identity::team/${string}`;
+export declare const toTeamId: (ari: TeamARI | string) => string;
+export declare const toTeamARI: (teamId: string) => TeamARI;

package/dist/types/common/utils/error/index.d.ts

@@ -0,0 +1,91 @@
+export declare enum ErrorCategory {
+    NotFound = "NotFound",
+    NotPermitted = "NotPermitted",
+    MalformedInput = "MalformedInput",
+    Internal = "Internal"
+}
+export declare enum StatusCode {
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    TIMEOUT = 408,
+    GONE = 410,
+    PAYLOAD_TOO_LARGE = 413
+}
+export declare function isAuthError(error?: Error | HttpError): boolean;
+export declare function isErrorStatusCode(statusCode: number, error?: Error | HttpError): boolean;
+export declare function doesErrorContainStatus(statusCode: number, message: string): boolean;
+export type DirectoryErrorCode = 'MISSING_ERROR_MESSAGE';
+export declare enum TeamErrorType {
+    TEAM_NOT_ACTIVE = "Team must be active"
+}
+export type ErrorObjectType = {
+    code?: string;
+    message?: TeamErrorType;
+};
+export type SingleError = {
+    status?: number;
+    error?: string;
+};
+export type RestJsonErrorResponse = {
+    errors: (TeamErrorType | ErrorObjectType)[];
+    timestamp?: string;
+} & SingleError;
+declare class CommonError extends Error {
+    message: string;
+    name: string;
+    stack: string;
+    constructor(message?: string);
+}
+export declare class DefaultError extends CommonError {
+    constructor({ message }: {
+        message?: string;
+    });
+}
+/**
+ * These errors will not fail UFO experiences
+ */
+export declare class SLOIgnoreError extends CommonError {
+    constructor({ message }: {
+        message?: string;
+    });
+}
+interface HttpErrorArguments {
+    message: string;
+    status: number;
+    traceId?: string;
+    path?: string;
+}
+export declare class HttpError extends CommonError {
+    status: number;
+    traceId?: string;
+    path?: string;
+    constructor({ message, status, traceId, path }: HttpErrorArguments);
+}
+/**
+ * These errors will not fail UFO experiences
+ */
+export declare class SLOIgnoreHttpError extends HttpError {
+    constructor(props: HttpErrorArguments);
+}
+interface ResultErrorData {
+    category: string;
+    message: string;
+    fields?: object;
+}
+interface FieldError {
+    message: string;
+    field: string;
+}
+export interface ErrorData {
+    category: string;
+    message: string;
+    fields?: FieldError[];
+}
+export declare class GraphQLError extends CommonError {
+    fields?: any;
+    category?: string;
+    constructor({ message, category, fields }: Partial<ResultErrorData>);
+    static from: (rawErrors: ErrorData[]) => GraphQLError;
+}
+export declare function isNetworkError(error: Error): boolean;
+export {};

package/dist/types/common/utils/filter-null.d.ts

@@ -0,0 +1 @@
+export declare function filterNull<T>(x?: T): x is Exclude<T, null>;

package/dist/types/common/utils/http.d.ts

@@ -0,0 +1,31 @@
+export declare const EXPONENTIAL_BACKOFF_RETRY_POLICY: {
+    INITIAL_DELAY: number;
+    MAX_RETRIES: number;
+    JITTER: boolean;
+};
+/**
+ * Checks whether a status code is a 5xx HTTP code.
+ * @param {number} status HTTP status code
+ */
+export declare function is5xx(status: number): boolean;
+export declare function isFetchResponse(data: unknown): data is {
+    response: Response;
+};
+type ToTryFunctionArgs = any[];
+type ToTryFunction<T> = (...args: ToTryFunctionArgs) => Promise<T>;
+type RetryIfCallback<T> = (a: T) => boolean;
+interface WithExponentialBackoffOptions<T> {
+    initial: number;
+    jitter?: boolean;
+    max: number;
+    retryIf?: RetryIfCallback<T>;
+}
+/**
+ * Transparently wrap a function so that it is retried until it succeeds or reaches a max retry limit.
+ * The returned function has the same signature as the wrapped function.
+ *
+ * Modified from https://jsfiddle.net/pajtai/pLka0ow9/
+ */
+export declare function withExponentialBackoff<ResponseType>(toTry: ToTryFunction<ResponseType>, hofOptions?: WithExponentialBackoffOptions<ResponseType>): (...args: ToTryFunctionArgs) => Promise<ResponseType>;
+export declare const fetchWithExponentialBackoff: (...args: ToTryFunctionArgs) => Promise<Response>;
+export {};

package/dist/types/common/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { sortMembersByType } from './sort-teams';
+export { isInvited, isMember, isNonMember, isRequestingJoin } from './team';

package/dist/types/common/utils/permissions/constants.d.ts

@@ -0,0 +1,23 @@
+import { type TeamMembershipSettings, type TeamPermission } from '../../../types/team';
+import { type TeamAction } from './types';
+export type PermissionMap = Required<Record<TeamAction, boolean>>;
+export declare const allPermissions: (defaultPermission: boolean, isMember: boolean) => PermissionMap;
+export declare const vanityActions: TeamAction[];
+export declare const openPermissions: (permission: TeamPermission | undefined) => {
+    JOIN_TEAM: boolean;
+    REQUEST_TO_JOIN: boolean;
+    CANCEL_JOIN_REQUEST: boolean;
+    APPROVE_JOIN_REQUEST: boolean;
+    REJECT_JOIN_REQUEST: boolean;
+};
+export declare const inviteOnlyPermissions: (permission: TeamPermission | undefined) => {
+    REQUEST_TO_JOIN: boolean;
+    CANCEL_JOIN_REQUEST: boolean;
+};
+export declare const SCIMSyncTeamPermissions: (isMember: boolean, isOrgAdmin: boolean) => {
+    EDIT_DESCRIPTION: boolean;
+    EDIT_TEAM_SETTINGS: boolean;
+    EDIT_TEAM_LINK: boolean;
+    EDIT_TEAM_NAME: boolean;
+};
+export declare const getPermissionMap: (settings: TeamMembershipSettings, permission: TeamPermission | undefined, isMember: boolean, isOrgAdmin: boolean) => PermissionMap;

package/dist/types/common/utils/permissions/has-permission.d.ts

@@ -0,0 +1,31 @@
+import { type TeamMembership } from '../../../types/membership';
+import { type TeamMembershipSettings, type TeamPermission } from '../../../types/team';
+import { type TeamAction, type TeamPermissions } from './types';
+export declare function hasPermission(action: TeamAction, settings: TeamMembershipSettings, permission: TeamPermission | undefined, isPeopleBrowseEnabled: boolean, currentUserMembership: TeamMembership | undefined, teamVisibilityPermissions?: TeamPermissions): boolean;
+type PermissionOptions = {
+    /**
+     * The teams membership settings, "OPEN" | "MEMBER_INVITE" | "EXTERNAL"
+     */
+    membershipSettings: TeamMembershipSettings;
+    /**
+     * The users permission for the team, "FULL_WRITE" | "FULL_READ" | "NONE"
+     */
+    teamPermission: TeamPermission | undefined;
+    /**
+     * Is the user a member of the team
+     */
+    isMemberOfTeam: boolean;
+    /**
+     * Is the user an org admin
+     */
+    isOrgAdmin: boolean;
+};
+/**
+ * Determines if a user has permission perform a given action on a team
+ */
+export declare function userCan(action: TeamAction, options: PermissionOptions): boolean;
+/**
+ * @deprecated Use `userCan` instead, it gives better visibility into the option mappings
+ */
+export declare function hasPermissionForAction(action: TeamAction, settings: TeamMembershipSettings, permission: TeamPermission | undefined, isMemberOfTeam: boolean, isOrgAdmin?: boolean): boolean;
+export {};

package/dist/types/common/utils/permissions/index.d.ts

@@ -0,0 +1,3 @@
+export { hasPermission, hasPermissionForAction, userCan } from './has-permission';
+export { AllTeamActions } from './types';
+export type { TeamAction } from './types';

package/dist/types/common/utils/permissions/types.d.ts

@@ -0,0 +1,7 @@
+export declare const AllTeamActions: readonly ["ADD_MEMBER_TO_TEAM", "JOIN_TEAM", "REQUEST_TO_JOIN", "CANCEL_JOIN_REQUEST", "APPROVE_JOIN_REQUEST", "REJECT_JOIN_REQUEST", "REMOVE_MEMBER_FROM_TEAM", "CANCEL_INVITE", "LEAVE_TEAM", "REMOVE_AGENT_FROM_TEAM", "ADD_AGENT_TO_TEAM", "EDIT_TEAM_NAME", "EDIT_DESCRIPTION", "EDIT_PROFILE_HEADER", "EDIT_TEAM_LINK", "EDIT_TEAM_SETTINGS", "EDIT_TEAM_MEMBERSHIP", "DELETE_TEAM"];
+export type TeamAction = (typeof AllTeamActions)[number];
+export type TeamPermissions = {
+    canCreateTeams: boolean;
+    canViewTeams: boolean;
+    canAdminTeams?: boolean;
+};

package/dist/types/common/utils/sort-teams.d.ts

@@ -0,0 +1,2 @@
+import { type TeamMembership } from '../../types';
+export declare const sortMembersByType: (members: TeamMembership[], currentAccountId?: string) => TeamMembership[];

package/dist/types/common/utils/status-code-handlers-provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Our REST clients are initialised when their module loads which makes it tricky for them to consume the `statusCodeHandlers` prop passed to App from the host application.
+ * This is a temporary measure to enable the clients to consume `statusCodeHandlers`.
+ * The long term solution is to replace our REST clients with Apollo client custom resolvers
+ * This will unify all remote data handling under the apollo-client module which is able to easily receive `statusCodeHandlers` as it is initialised within the React portion of our app.
+ */
+type StatusCodeHandler = (response: Response) => void;
+export interface StatusCodeHandlerMap {
+    [statusCode: number]: StatusCodeHandler;
+}
+export declare const statusCodeHandlersProvider: {
+    handlers: StatusCodeHandlerMap;
+    get(): StatusCodeHandlerMap;
+    setHandlers(handlers: StatusCodeHandlerMap): void;
+};
+export declare function handleResponse(response: Response): void;
+export {};

package/dist/types/common/utils/team.d.ts

@@ -0,0 +1,5 @@
+import { type TeamMembership } from '../../types';
+export declare function isInvited(member?: TeamMembership): member is TeamMembership & boolean;
+export declare const isNonMember: (member?: TeamMembership) => boolean;
+export declare const isRequestingJoin: (member?: TeamMembership) => boolean;
+export declare const isMember: (member?: TeamMembership) => boolean;

package/dist/types/common/utils/ufo/constants.d.ts

@@ -0,0 +1,5 @@
+import { TeamsUFOExperience } from './index';
+declare const TeamsClientExperienceKeyList: readonly ["getAllTeams", "getTeamById", "updateTeamById", "querySettings", "queryFeatureFlags", "queryTeamMemberships", "queryUser", "inviteUsersToTeam", "getMyTeamMembership", "getTeamLinksByTeamId", "createTeamLink", "updateTeamLink", "deleteTeamLink", "reorderTeamLink", "acceptTeamInvitation", "declineTeamInvitation", "selfJoinTeam", "cancelJoinRequest", "acceptJoinRequest", "declineJoinRequest", "deleteTeamMembership", "revokeTeamInvite", "deleteTeam", "isSingleFullMemberTeam", "createTeam", "createExternalTeam", "getProfileWithMutability", "getIsSiteAdmin", "addUsersToTeam", "removeTeamMemberships", "getRecommendedProducts", "joinOrRequestDefaultAccessToProductsBulk", "getReadMediaToken", "getWriteUserMediaToken", "updateUserHeaderImage", "getWriteTeamMediaToken", "getSoftDeletedTeamById", "restoreTeam", "getUserInSiteUserBase", "getLinkedTeamsBulk", "getTeamProfileDetails", "getUserContainers", "getPermissions", "getUserManageConfig", "getMyAvatarUploadedStatus", "deleteUserAvatar", "getTeamLinkIcons", "getTeamInSlack", "getOrgScope", "restoreTeamToSyncedGroup", "getTeamAndGroupDiff", "linkExistingTeamToGroup", "fetchUserAvatarInfo", "getOrgEligibilityForManagedTeams", "updateUser", "updateUserAvatar", "disconnectTeamInSlack", "updateTeamInSlack"];
+export type TeamsClientExperienceKeys = (typeof TeamsClientExperienceKeyList)[number];
+export declare const TEAMS_CLIENT_EXPERIENCES: Map<"getAllTeams" | "getOrgEligibilityForManagedTeams" | "createTeam" | "getPermissions" | "getLinkedTeamsBulk" | "getTeamProfileDetails" | "getOrgScope" | "getTeamById" | "updateTeamById" | "querySettings" | "queryFeatureFlags" | "queryTeamMemberships" | "queryUser" | "inviteUsersToTeam" | "getMyTeamMembership" | "getTeamLinksByTeamId" | "createTeamLink" | "updateTeamLink" | "deleteTeamLink" | "reorderTeamLink" | "acceptTeamInvitation" | "declineTeamInvitation" | "selfJoinTeam" | "cancelJoinRequest" | "acceptJoinRequest" | "declineJoinRequest" | "deleteTeamMembership" | "revokeTeamInvite" | "deleteTeam" | "isSingleFullMemberTeam" | "createExternalTeam" | "getProfileWithMutability" | "getIsSiteAdmin" | "addUsersToTeam" | "removeTeamMemberships" | "getRecommendedProducts" | "joinOrRequestDefaultAccessToProductsBulk" | "getReadMediaToken" | "getWriteUserMediaToken" | "updateUserHeaderImage" | "getWriteTeamMediaToken" | "getSoftDeletedTeamById" | "restoreTeam" | "getUserInSiteUserBase" | "getUserContainers" | "getUserManageConfig" | "getMyAvatarUploadedStatus" | "deleteUserAvatar" | "getTeamLinkIcons" | "getTeamInSlack" | "restoreTeamToSyncedGroup" | "getTeamAndGroupDiff" | "linkExistingTeamToGroup" | "fetchUserAvatarInfo" | "updateUser" | "updateUserAvatar" | "disconnectTeamInSlack" | "updateTeamInSlack", TeamsUFOExperience>;
+export {};

package/dist/types/common/utils/ufo/index.d.ts

@@ -0,0 +1,6 @@
+import { UFOExperience } from '@atlaskit/ufo';
+import { type HttpError } from '../error';
+export declare class TeamsUFOExperience extends UFOExperience {
+    abortWithError(error: Error | HttpError, reason: string): Promise<boolean | null>;
+    failWithError(error: Error | HttpError | unknown): Promise<boolean | null>;
+}

package/dist/types/common/utils/ufo/utils.d.ts

@@ -0,0 +1,11 @@
+import { HttpError } from '../error';
+export declare const createErrorMetadata: (error: Error | HttpError) => {
+    error: {
+        name: string;
+        message: string;
+        stack: string | undefined;
+        traceId: string | undefined;
+        status: number | undefined;
+    };
+};
+export declare const isIgnoredError: (error: Error) => boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+export { HttpError } from './common/utils/error';
+export type { AllTeamsQuery, OriginQuery } from './services/legion-client';
+export { isTeamMembershipWithUser } from './types/membership';
+export { teamsClient, TeamsClient } from './services';
+export { useTeamsClientSetup, useTeamsClientSetupNext, } from './services/hooks/use-teams-client-setup';
+export { AllTeamActions, hasPermission } from './common/utils/permissions';
+export type { TeamAction } from './common/utils/permissions';
+export { initialiseSentry } from './services/sentry/utils/initialise-sentry';
+export { logException, logInfoMessage } from './services/sentry/main';
+export type { SentryClient } from './services/sentry/types';
+export { userInfoProvider, UserInfoProvider } from './services/user-info-provider';
+export { sortMembersByType, isInvited, isMember, isNonMember, isRequestingJoin, } from './common/utils';
+export { toUserARI, toUserId, toTeamARI, toTeamId } from './common/utils/ari';
+export { useLazyQueryLight, useQueryLight, UseQueryLightError, type ActualGraphQLError, } from './services/use-query-light';
+export type { FetchMoreArgs, QueryOptions } from './services/use-query-light';

package/dist/types/mocks/endpoints.d.ts

@@ -0,0 +1,22 @@
+import type FakerType from 'faker';
+import type fetchMockType from 'fetch-mock/cjs/client';
+type MockConfig = {
+    fetchMock: typeof fetchMockType;
+    delay?: number;
+    faker?: typeof FakerType;
+    restoreFetchMock?: boolean;
+    endpointConfig?: {
+        teamMembership?: MockTeamMembershipConfig;
+        teamType?: 'open' | 'inviteOnly' | 'external';
+        memberStatus?: 'requestingToJoin' | 'notMember' | 'fullMember';
+    };
+};
+type MockTeamMembershipConfig = {
+    count?: number;
+};
+export declare const mockTeamsClientEndpoints: (config: MockConfig) => void;
+export declare const mockTeamsClientRequestingToJoinEndpoints: (config: MockConfig) => void;
+export declare const mockTeamsClientNotMemberEndpoints: (config: MockConfig) => void;
+export declare const mockTeamsClientAdminEndpoints: (config: MockConfig) => void;
+export declare const mockTeamsClientInviteOnlyMemberEndpoints: (config: MockConfig) => void;
+export {};

package/dist/types/mocks/generate-data.d.ts

@@ -0,0 +1,16 @@
+import type FakerType from 'faker';
+import { type TeamMembershipQueryResponse } from '../services/agg-client/utils/queries/team-membership-query';
+import { type Team, type TeamMembership } from '../types';
+type MockConfig = {
+    faker: typeof FakerType;
+};
+export declare const randomTeamMembership: ({ faker }: MockConfig, customProps?: {}) => TeamMembership;
+export declare const randomTeamMemberships: (config: MockConfig, n?: number, customProps?: {}) => TeamMembership[];
+export declare const fixedTeamMemberships: (n?: number) => TeamMembership[];
+export declare function randomReturnedNewTeamData({ faker }: MockConfig, customProps?: Partial<Team>): Team;
+export declare const mockTeamMembershipResponseWithNEdges: ({ faker }: MockConfig, n: number) => {
+    data: {
+        team: TeamMembershipQueryResponse;
+    };
+};
+export {};

package/dist/types/mocks/index.d.ts

@@ -0,0 +1,2 @@
+export { mockTeamsClientEndpoints, mockTeamsClientRequestingToJoinEndpoints, mockTeamsClientAdminEndpoints, mockTeamsClientNotMemberEndpoints, mockTeamsClientInviteOnlyMemberEndpoints, } from './endpoints';
+export { randomReturnedNewTeamData, randomTeamMembership, randomTeamMemberships, fixedTeamMemberships, } from './generate-data';

package/dist/types/mocks/invitations.d.ts

@@ -0,0 +1,11 @@
+export declare const getJoinOrRequestDefaultAccessToProductsBulkSuccessResponse: (aris: string[]) => {
+    ari: string;
+    result: string;
+    resultsV2: {
+        [x: string]: {
+            accessMode: string;
+            role: string;
+        }[];
+    };
+    errorReason: null;
+}[];

package/dist/types/mocks/responses.d.ts

@@ -0,0 +1,75 @@
+import { type TeamMembershipQueryResponse } from '../services/agg-client/utils/queries/team-membership-query';
+import { type RecommendationsResponse } from '../services/invitations-client/types';
+import { type LegionTeamGetResponseV4 } from '../services/legion-client/types';
+import { type TeamMembership } from '../types';
+export declare const MOCK_ME_RESPONSE: {
+    email: string;
+    nickname: string;
+    characteristics: {
+        not_mentionable: null;
+    };
+    extended_profile: {
+        job_title: string;
+        organization: string;
+        department: string;
+        location: string;
+    };
+    account_id: string;
+    name: string;
+    zoneinfo: string;
+    locale: string;
+    privacy_settings: {
+        name: string;
+        nickname: string;
+        picture: string;
+        job_title: string;
+        department: string;
+        organization: string;
+        location: string;
+        zoneinfo: string;
+        email: string;
+        phone_number: string;
+        team_type: string;
+    };
+    picture: any;
+    account_type: string;
+    account_status: string;
+};
+export declare const MOCK_PROFILE_MUTABILITY_RESPONSE: {
+    account_id: string;
+    account_type: string;
+    account_status: string;
+    characteristics: {
+        not_mentionable: null;
+    };
+    email: string;
+    extended_profile: {
+        job_title: string;
+        organization: string;
+        department: string;
+        location: string;
+    };
+    locale: string;
+    last_updated: string;
+    name: string;
+    nickname: string;
+    not_editable: {
+        field: string;
+        reason: string;
+    }[];
+    picture: any;
+};
+export declare const MOCK_MEMBERS_ME_MEMBER_RESPONSE: TeamMembership;
+export declare const MOCK_MEMBERS_ME_ADMIN_RESPONSE: TeamMembership;
+export declare const MOCK_MEMBERS_ME_REQUESTING_RESPONSE: TeamMembership;
+export declare const MOCK_TEAM_MEMBERSHIP_RESPONSE: {
+    data: {
+        team: TeamMembershipQueryResponse;
+    };
+};
+export declare const MOCK_INVITE_ONLY_TEAM_RESPONSE: LegionTeamGetResponseV4;
+export declare const MOCK_EXTERNAL_TEAM_RESPONSE: LegionTeamGetResponseV4;
+export declare const MOCK_INVITE_ONLY_TEAM_WRITE_PERMISSION_RESPONSE: LegionTeamGetResponseV4;
+export declare const MOCK_OPEN_TEAM_RESPONSE: LegionTeamGetResponseV4;
+export declare const MOCK_OPEN_TEAM_WRITE_PERMISSION_RESPONSE: LegionTeamGetResponseV4;
+export declare const MOCK_PRODUCT_RECOMMENDATIONS_RESPONSE: RecommendationsResponse;

package/dist/types/mocks/team-link.d.ts

@@ -0,0 +1,7 @@
+import type FakerType from 'faker';
+import { type TeamLink } from '../types';
+type MockConfig = {
+    faker: typeof FakerType;
+};
+export declare const randomTeamLinks: ({ faker }: MockConfig) => (n?: number, customProps?: {}) => TeamLink[];
+export {};

package/dist/types/mocks/team.d.ts

@@ -0,0 +1,14 @@
+import type FakerType from 'faker';
+import { type TeamMembership, type TeamWithMemberships } from '../types/membership';
+import { type Team, type TeamAvatarImage, type TeamWithImageUrls } from '../types/team';
+type MockConfig = {
+    faker: typeof FakerType;
+};
+export declare const randomTeamMembership: ({ faker }: MockConfig) => (customProps?: {}) => TeamMembership;
+export declare const randomTeamMemberships: (config: MockConfig) => (n?: number, customProps?: {}) => TeamMembership[];
+export declare const randomHeaderImage: ({ faker }: MockConfig) => () => string;
+export declare const randomTeamImages: ({ faker }: MockConfig) => (customImage?: string) => TeamAvatarImage;
+export declare const randomBasicTeam: ({ faker }: MockConfig) => (customProps?: {}) => Team;
+export declare const randomFullTeam: ({ faker }: MockConfig) => (customProps?: {}) => TeamWithImageUrls;
+export declare const randomTeamWithMemberships: ({ faker }: MockConfig) => (team: TeamWithImageUrls, customProps?: {}) => TeamWithMemberships;
+export {};

package/dist/types/mocks/user.d.ts

@@ -0,0 +1,15 @@
+import type FakerType from 'faker';
+import { type TeamsClientUser as User } from '../types/user';
+type MockConfig = {
+    faker: typeof FakerType;
+};
+export declare const createUser: (id: string, customProps?: {}) => User;
+export declare const randomUser: ({ faker }: MockConfig, customProps?: {}) => User;
+export declare const randomUsers: (n: number | undefined, config: MockConfig) => User[];
+export declare const fixedUsers: (n?: number) => User[];
+export declare const JohnWick: User;
+export declare const DenzelWashington: User;
+export declare const ClosedUser: User;
+export declare const InactiveUser: User;
+export declare const AgentUser: User;
+export {};

package/dist/types/mocks/with-faker.d.ts

@@ -0,0 +1,11 @@
+import type FakerType from 'faker';
+type MockConfig = {
+    faker: typeof FakerType;
+};
+export declare const teamsClientMocks: (config: MockConfig) => {
+    randomBasicTeam: (customProps?: {}) => import("../types").Team;
+    randomFullTeam: (customProps?: {}) => import("../types").TeamWithImageUrls;
+    randomTeamWithMemberships: (team: import("../types").TeamWithImageUrls, customProps?: {}) => import("../types").TeamWithMemberships;
+    randomTeamLinks: (n?: number, customProps?: {}) => import("../types").TeamLink[];
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { type MembershipState, type TeamMembership } from '../../types';
+import { type ClientConfig } from '../base-client';
+import { BaseGraphQlClient } from '../graphql-client';
+import { type AGGPageInfoVariables, type ResultWithPageInfo } from './types';
+import { type TeamsUserQueryResponse } from './utils/queries/user-query';
+export declare class AGGClient extends BaseGraphQlClient {
+    constructor(baseUrl: string, config: ClientConfig);
+    setBaseUrl(baseUrl: string): void;
+    queryTeamMemberships(teamId: string, membershipState?: MembershipState[], pageInfo?: AGGPageInfoVariables): Promise<ResultWithPageInfo<TeamMembership>>;
+    queryAGGUser(userId: string): Promise<TeamsUserQueryResponse>;
+}
+export declare const aggClient: AGGClient;