@atlaskit/teams-client 4.0.0

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

@@ -0,0 +1,117 @@
+import { type TeamMembership } from './membership';
+/**
+ * @private
+ * @deprecated state has been removed as part of migration to V4
+ */
+export type DeprecatedTeamState = 'DISBANDED';
+export type TeamState = 'ACTIVE' | 'PURGED' | DeprecatedTeamState;
+export type TeamMembershipSettings = 'OPEN' | 'MEMBER_INVITE' | 'EXTERNAL';
+export type TeamDiscoverability = 'DISCOVERABLE';
+export type TeamRestriction = 'ORG_MEMBERS' | 'NO_RESTRICTION';
+export type TeamPermission = 'FULL_WRITE' | 'FULL_READ' | 'NONE';
+export type ScopeMode = 'ORG_SCOPE_MODE' | 'SITE_SCOPE_MODE';
+export interface Scope {
+    id: string;
+    name: string;
+}
+export interface TeamAvatarImage {
+    largeAvatarImageUrl: string;
+    smallAvatarImageUrl: string;
+    largeHeaderImageUrl: string;
+    smallHeaderImageUrl: string;
+}
+/**
+ * @type Team
+ * Team type which doean't include the avatar image urls
+ */
+export interface Team {
+    id: string;
+    displayName: string;
+    description: string;
+    state: TeamState;
+    membershipSettings: TeamMembershipSettings;
+    /**
+     * @private
+     * @deprecated field has been removed as part of migration to V4. Will always be DISCOVERABLE
+     */
+    discoverable?: TeamDiscoverability;
+    organizationId?: string;
+    /**
+     * @private
+     * @deprecated field has been removed as part of migration to V4
+     */
+    restriction: TeamRestriction;
+    creatorId?: string;
+    permission?: TeamPermission;
+    /**
+     * @private
+     * @deprecated field has been removed as part of migration to V4
+     */
+    creatorDomain?: string;
+    memberIds?: string[];
+    membership?: {
+        members?: TeamMembership[];
+        errors?: string[];
+    };
+    /**
+     * @private
+     * @deprecated use organizationId instead
+     */
+    orgId?: string;
+    scopeMode?: ScopeMode;
+    isVerified?: boolean;
+}
+/**
+ * @type TeamWithImageUrls
+ */
+export interface TeamWithImageUrls extends Team, TeamAvatarImage {
+}
+export interface SoftDeletedTeamResponse {
+    teamResponse: {
+        displayName: string;
+        expiry: string;
+    };
+}
+export interface SoftDeletedTeam {
+    id: string;
+    displayName: string;
+    expiry: string;
+}
+/**
+ * @type ExternalReference
+ * Payload type for the createTeam API, when the team membershipSetting is EXTERNAL
+ * @property {string} source - The source of the external reference, e.g., "ATLASSIAN_GROUP".
+ * @property {string} id - Group ID of source
+ */
+export interface ExternalReference {
+    source: string;
+    id: string;
+    displayName?: string;
+    syncTeamName?: boolean;
+}
+export type TeamsPermissionApi = 'CAN_CREATE_TEAMS' | 'CAN_VIEW_TEAMS' | 'CAN_ADMIN_TEAMS';
+/**
+ * @type TeamsPermissionFromApi
+ * Mapped response from GET /api/v4/teams/permission/self/organization/{orgId}
+ */
+export type TeamsPermissionFromApi = {
+    permissions: TeamsPermissionApi[];
+};
+export type LinkedTeam = Pick<TeamWithImageUrls, 'id' | 'displayName' | 'description' | 'organizationId' | 'isVerified' | 'smallAvatarImageUrl' | 'largeAvatarImageUrl'> & {
+    linkToTeamProfile: string;
+    externalReference: {
+        id: string;
+    };
+    scopeMode: ScopeMode;
+    scope: Scope;
+};
+export interface LinkedTeamsBulkResponse {
+    teams: LinkedTeam[];
+}
+export interface LinkedTeamsProfileDetails {
+    profileUrl: string;
+}
+export interface OrgScope {
+    scopeMode: ScopeMode;
+    scopes: Scope[];
+}

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

@@ -0,0 +1,41 @@
+type UserPrivacyLevel = 'private' | 'domain' | 'public';
+export type UserStatus = 'active' | 'inactive' | 'closed';
+export type UserType = 'bot' | 'user' | 'agent';
+interface UserPrivacy {
+    level: UserPrivacyLevel;
+    domain: string;
+    isBlacklistedDomain: boolean;
+}
+export interface TeamsClientUser {
+    id: string;
+    isCurrentUser?: boolean;
+    fullName: string;
+    nickname?: string;
+    email?: string;
+    title?: string;
+    timezone?: string;
+    localTime?: string;
+    locale?: string;
+    preferredLanguage?: string;
+    location?: string;
+    companyName?: string;
+    department?: string;
+    position?: string;
+    avatarUrl?: string;
+    headerImageUrl?: string;
+    privacy?: UserPrivacy;
+    status?: UserStatus;
+    statusModifiedDate?: number;
+    isBot?: boolean;
+    isNotMentionable?: boolean;
+    phoneNumber?: string;
+    userType?: UserType;
+    isAgent?: boolean;
+}
+export interface UserInSiteUserbase {
+    isPresent: boolean;
+}
+declare const EditableUserFieldList: readonly ["title", "department", "companyName", "location", "phoneNumber", "fullName", "nickname", "locale", "email"];
+export type EditableUserFields = Pick<TeamsClientUser, (typeof EditableUserFieldList)[number]>;
+export declare const isEditableUserField: (key: string) => key is "title" | "department" | "companyName" | "location" | "phoneNumber" | "fullName" | "nickname" | "locale" | "email";
+export {};

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/common/utils/filter-null.d.ts

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

package/dist/types-ts4.5/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-ts4.5/common/utils/index.d.ts

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

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/common/utils/permissions/types.d.ts

@@ -0,0 +1,26 @@
+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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/common/utils/ufo/constants.d.ts

@@ -0,0 +1,64 @@
+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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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;