@atlaskit/teams-client 4.0.0

package/dist/types/services/public-api-client/generated/data-contracts.d.ts

@@ -0,0 +1,112 @@
+export interface PublicApiFetchResponsePublicApiMembershipAccountId {
+    pageInfo?: PublicApiPageInfoAccountId;
+    results?: PublicApiMembership[];
+}
+export interface PublicApiMembership {
+    accountId?: string;
+}
+export interface PublicApiMembershipAddPayload {
+    /**
+     * @maxItems 50
+     * @minItems 1
+     * @uniqueItems true
+     */
+    members: PublicApiMembership[];
+}
+export interface PublicApiMembershipAddResponse {
+    /** @uniqueItems true */
+    errors?: PublicApiMembershipCodedError[];
+    /** @uniqueItems true */
+    members?: PublicApiMembership[];
+}
+export interface PublicApiMembershipCodedError {
+    accountId?: string;
+    code?: string;
+    message?: string;
+}
+export interface PublicApiMembershipFetchPayload {
+    /** Pagination cursor, only members after the cursor will be returned */
+    after?: string;
+    /**
+     * Maximum number of members to be returned
+     * @format int32
+     * @max 50
+     * @default 50
+     */
+    first?: number;
+}
+export interface PublicApiMembershipRemovePayload {
+    /**
+     * @maxItems 50
+     * @minItems 1
+     * @uniqueItems true
+     */
+    members: PublicApiMembership[];
+}
+export interface PublicApiMembershipRemoveResponse {
+    /** @uniqueItems true */
+    errors?: PublicApiMembershipCodedError[];
+}
+export interface PublicApiOverallCodedError {
+    code?: string;
+    message?: string;
+}
+export interface PublicApiPageInfoAccountId {
+    endCursor?: string;
+    hasNextPage?: boolean;
+}
+export interface PublicApiTeamCreationPayload {
+    /**
+     * @minLength 0
+     * @maxLength 360
+     */
+    description: string;
+    /**
+     * @minLength 1
+     * @maxLength 80
+     */
+    displayName: string;
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    siteId?: string;
+    teamType: 'OPEN' | 'MEMBER_INVITE';
+}
+export interface PublicApiTeamResponse {
+    description?: string;
+    displayName?: string;
+    organizationId?: string;
+    teamId?: string;
+    teamType?: 'OPEN' | 'MEMBER_INVITE';
+    userPermissions?: PublicApiUserPermissions;
+}
+export interface PublicApiTeamResponseWithMembers {
+    description?: string;
+    displayName?: string;
+    /** @uniqueItems true */
+    members?: PublicApiMembership[];
+    organizationId?: string;
+    teamId?: string;
+    teamType?: 'OPEN' | 'MEMBER_INVITE';
+    userPermissions?: PublicApiUserPermissions;
+}
+export interface PublicApiTeamUpdatePayload {
+    /**
+     * @minLength 0
+     * @maxLength 360
+     */
+    description?: string;
+    /**
+     * @minLength 1
+     * @maxLength 80
+     * @pattern .*\S+.*
+     */
+    displayName?: string;
+}
+export interface PublicApiUserPermissions {
+    ADD_MEMBERS?: boolean;
+    DELETE_TEAM?: boolean;
+    REMOVE_MEMBERS?: boolean;
+    UPDATE_TEAM?: boolean;
+}

package/dist/types/services/public-api-client/index.d.ts

@@ -0,0 +1,41 @@
+import { RestClient } from '../rest-client';
+import { type PublicApiTeamResponse, type PublicApiTeamResponseWithMembers } from './generated/data-contracts';
+/**
+ * @deprecated migrate to generated types
+ */
+interface Member {
+    accountId: string;
+}
+/**
+ * @deprecated migrate to generated types
+ */
+interface AddMembershipReponse {
+    members: Member[];
+    errors: {
+        accountId: string;
+        code: string;
+        message: string;
+    }[];
+}
+/**
+ * @deprecated migrate to generated types
+ */
+interface RemoveMembershipReponse {
+    errors: {
+        accountId: string;
+        code: string;
+        message: string;
+    }[];
+}
+export interface PublicApiClient {
+    addUsersToTeam(teamId: string, members: Member[]): Promise<AddMembershipReponse>;
+    removeTeamMemberships(teamId: string, members: Member[]): Promise<RemoveMembershipReponse>;
+}
+export declare class PublicApiClient extends RestClient implements PublicApiClient {
+    constructor(serviceUrlRoot: string);
+    getTeamDetails(teamId: string): Promise<PublicApiTeamResponse>;
+    getTeamMembers(teamId: string, first?: number, after?: string): Promise<PublicApiTeamResponseWithMembers>;
+    restoreTeam(teamId: string): Promise<void>;
+}
+declare const _default: PublicApiClient;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { HttpError } from '../../common/utils/error';
+import { BaseClient, type ClientConfig } from '../base-client';
+interface FetchOptions {
+    headers?: {
+        [key: string]: string;
+    };
+    ignoreResponse?: boolean;
+    body?: any;
+    method?: string;
+    shouldLogError?: (e: HttpError) => boolean;
+}
+export declare function resetRedirectCountOnceFlag(): void;
+export declare class RestClient extends BaseClient {
+    constructor({ serviceUrl, config, }: {
+        serviceUrl: string;
+        config?: ClientConfig;
+    });
+    serviceUrl: string;
+    setServiceUrl(serviceUrl: string): void;
+    getResource<T>(path: string, fetchOptions?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    getResourceCached<T>(path: string, fetchOptions?: Omit<FetchOptions, 'method' | 'body'>, cacheOptions?: {
+        expiration: number;
+    }): Promise<T>;
+    postResource<T>(path: string, data?: Record<string, unknown>, fetchOptions?: FetchOptions): Promise<T>;
+    postResourceRaw<T>(path: string, data?: string, fetchOptions?: FetchOptions): Promise<T>;
+    patchResource<T>(path: string, data?: Record<string, unknown>): Promise<T>;
+    putResource<T>(path: string, data?: Record<string, unknown>, additionalFetchOptions?: FetchOptions): Promise<T>;
+    deleteResource<T>(path: string, options?: FetchOptions): Promise<T>;
+    /**
+     * This function is necessary for if `statusCodeHandler` prescribes a login
+     * redirect upon a 401 response.
+     * While the default redirect behaviour may be overriden, this function has
+     * been kept separate to ensure it cannot be overriden, lest a host
+     * application supply embeddable-directory with a custom handler that suffers
+     * the infinite redirect bug.
+     */
+    preventInfiniteRedirectLoop: (response: Response) => void;
+    makeRequest<T>(path: string, additionalFetchOptions?: FetchOptions): Promise<T>;
+}
+export {};

package/dist/types/services/rest-client/utils/cookie.d.ts

@@ -0,0 +1,5 @@
+export declare const REDIRECT_COUNT = "redirectCount";
+export declare const IDENTITY_CSRF_TOKEN = "avatar.csrf.token";
+export declare function setCookie(key: string, value: string | number): void;
+export declare function getCookieAsInteger(key: string, defaultValue?: number): number;
+export declare function clearCookie(key: string): void;

package/dist/types/services/rest-client/utils/parse-error-message.d.ts

@@ -0,0 +1 @@
+export declare function parseErrorMessage(response: Response): Promise<string>;

package/dist/types/services/rest-client/utils/parse-response.d.ts

@@ -0,0 +1 @@
+export declare function parseResponse(response: Response): Promise<any> | null;

package/dist/types/services/rest-client/utils/strip-uuid.d.ts

@@ -0,0 +1 @@
+export declare const stripUUIDFromPath: (path: string) => string;

package/dist/types/services/sentry/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SENTRY_PUBLIC_KEY = "1dc056d49dfe4df8961dc1b810e4620d";
+export declare const SENTRY_PROJECT_ID = "5988845";
+export declare const SENTRY_FEDRAMP_PUBLIC_KEY = "067abcc494be9a87b3cdf9416f2b97d5";
+export declare const SENTRY_FEDRAMP_PROJECT_ID = "47";
+export declare const SENTRY_DSN: string;

package/dist/types/services/sentry/index.d.ts

@@ -0,0 +1,3 @@
+export { addBreadcrumb, logException, logErrorMessage, logInfoMessage, createErrorHandler, logExceptionWithPackageContext, logErrorMessageWithPackageContext, logInfoMessageWithPackageContext, createErrorHandlerWithPackageContext, } from './main';
+export { useTeamsSentryClientSetup } from './utils/use-teams-sentry-client-setup';
+export type { CreateErrorHandler, SentryClient } from './types';

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

@@ -0,0 +1,36 @@
+import type { Breadcrumb } from '@sentry/browser';
+import { type CreateErrorHandler, type SentryTags } from './types';
+type Context = any & {
+    /**
+     * Any tags to be added to the event.
+     */
+    tags?: SentryTags;
+    packageName?: string;
+    packageVersion?: string;
+};
+export declare function logException(ex: Error | unknown, name: string, context?: Context): Promise<void>;
+export declare function logErrorMessage(message: string, context?: Context): void;
+export declare function logInfoMessage(message: string, context?: Context): void;
+export declare const createErrorHandler: CreateErrorHandler;
+export declare const logExceptionWithPackageContext: (packageContext: {
+    packageName: string;
+    packageVersion: string;
+}) => (ex: unknown, name: string, context?: any) => void;
+export declare const logErrorMessageWithPackageContext: (packageContext: {
+    packageName: string;
+    packageVersion: string;
+}) => (message: string, context?: any) => void;
+export declare const logInfoMessageWithPackageContext: (packageContext: {
+    packageName: string;
+    packageVersion: string;
+}) => (message: string, context?: any) => void;
+export declare const createErrorHandlerWithPackageContext: (packageContext: {
+    packageName: string;
+    packageVersion: string;
+}) => (meta: {
+    packageName: string;
+    packageVersion: string;
+    teamName: string;
+}, commonTags?: Record<string, string> | undefined) => import("./types").ErrorHandler;
+export declare function addBreadcrumb(crumb: string | Breadcrumb): Promise<void>;
+export {};

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

@@ -0,0 +1,36 @@
+import type { BrowserOptions, captureException, captureMessage as captureMessageSentry, init, Integrations, Scope } from '@sentry/browser';
+/** Duplicated type to avoid a dependency on teams-common */
+export type CreateErrorHandler = (meta: {
+    packageName: string;
+    packageVersion: string;
+    teamName: string;
+}, commonTags?: Record<string, string>) => ErrorHandler;
+export type ErrorHandler = (error: Error, message: string, tags?: Record<string, string>) => void;
+export interface SentryOptions extends BrowserOptions {
+    whitelistUrls?: (string | RegExp)[];
+    ignoreUrls?: (string | RegExp)[];
+}
+export interface SentryTags {
+    [key: string]: string;
+}
+export interface SentryClient {
+    init: typeof init;
+    Integrations: typeof Integrations;
+    withScope(callback: (scope: Scope) => void): void;
+    captureMessage: typeof captureMessageSentry;
+    captureException: typeof captureException;
+}
+export interface SentryInstallConfig {
+    env?: string;
+    version?: string;
+    noGlobals?: boolean;
+    /**
+     * @deprecated use `initialScope` instead
+     */
+    tags?: SentryTags;
+    initialScope?: {
+        tags?: SentryTags;
+    };
+    dsn?: string;
+    attachStacktrace?: boolean;
+}

package/dist/types/services/sentry/utils/get-sentry-config.d.ts

@@ -0,0 +1,2 @@
+import { type SentryInstallConfig, type SentryOptions } from '../types';
+export declare function getSentryConfig(options: SentryInstallConfig): SentryOptions;

package/dist/types/services/sentry/utils/initialise-sentry.d.ts

@@ -0,0 +1,2 @@
+import { type SentryClient, type SentryInstallConfig } from '../types';
+export declare function initialiseSentry(client: SentryClient, options: SentryInstallConfig): Promise<void>;

package/dist/types/services/sentry/utils/sentry-client.d.ts

@@ -0,0 +1,9 @@
+import { type SentryClient } from '../types';
+export type SentryClientConfig = {
+    appName?: string;
+    env?: string;
+};
+export declare let sentryClient: SentryClient | undefined;
+export declare const setSentryClient: (client: SentryClient) => void;
+export declare const getSentryClient: () => Promise<SentryClient | undefined>;
+export declare function setupSentryClient({ appName, env }: SentryClientConfig): Promise<void>;

package/dist/types/services/sentry/utils/use-teams-sentry-client-setup.d.ts

@@ -0,0 +1,2 @@
+import { type SentryClientConfig } from './sentry-client';
+export declare const useTeamsSentryClientSetup: (isSentryEnabled: boolean, config: SentryClientConfig) => import("..").SentryClient | undefined;

package/dist/types/services/teams-in-slack-client/index.d.ts

@@ -0,0 +1,27 @@
+import { RestClient } from '../rest-client';
+export declare class TeamsInSlackClient extends RestClient {
+    constructor(config?: {});
+    getTeamInSlack(teamId: string, teamName: string): Promise<{
+        connected: boolean;
+        slackChannelId: string;
+        slackChannelName: string;
+        usergroupHandle: string;
+        id: string;
+    }>;
+    disconnectTeamInSlack(teamId: string): Promise<{
+        connected: boolean;
+        slackChannelId: string;
+        slackChannelName: string;
+        usergroupHandle: string;
+        id: string;
+    }>;
+    updateTeamInSlack(teamId: string, channelId: string, usergroupHandle: string): Promise<{
+        connected: boolean;
+        slackChannelId: string;
+        slackChannelName: string;
+        usergroupHandle: string;
+        id: string;
+    }>;
+}
+declare const _default: TeamsInSlackClient;
+export default _default;

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

@@ -0,0 +1,10 @@
+export type ClientContext = {
+    cloudId: string;
+    orgId?: string;
+    userId?: string;
+};
+export type ClientContextProps = {
+    cloudId?: string | null;
+    orgId?: string;
+    userId?: string;
+};

package/dist/types/services/use-query-light/index.d.ts

@@ -0,0 +1,3 @@
+export { useQueryLight, useLazyQueryLight } from './main';
+export type { QueryOptions, FetchMoreArgs, ActualGraphQLError } from './types';
+export { UseQueryLightError } from './types';

package/dist/types/services/use-query-light/main.d.ts

@@ -0,0 +1,4 @@
+import { type DocumentNode } from 'graphql';
+import { type QueryOptions, type QueryResponse } from './types';
+export declare const useQueryLight: <TParams, TResult>(query: DocumentNode, options: QueryOptions<TParams>) => QueryResponse<TParams, TResult>;
+export declare const useLazyQueryLight: <TParams, TResult>(query: DocumentNode, options: Omit<QueryOptions<TParams>, 'skip'>) => [() => void, QueryResponse<TParams, TResult>];

package/dist/types/services/use-query-light/types.d.ts

@@ -0,0 +1,57 @@
+import { type GraphQLError } from 'graphql';
+export interface QueryOptions<TParams> {
+    serviceUrl: string;
+    variables?: TParams;
+    operationName: string;
+    skip?: boolean;
+    customHeaders?: Record<string, string>;
+}
+export declare enum ErrorCategory {
+    NotFound = "NotFound",
+    NotPermitted = "NotPermitted",
+    MalformedInput = "MalformedInput",
+    Internal = "Internal"
+}
+export declare class ActualGraphQLError extends Error {
+    extensions?: UseQueryLightErrorExtensions;
+    message: string;
+    path: readonly (string | number)[] | undefined;
+    category?: ErrorCategory;
+    type?: string;
+    constructor(message: string);
+}
+export interface QueryStatus<TResult> {
+    loading: boolean;
+    data?: TResult;
+    error?: UseQueryLightError;
+}
+type UseQueryLightErrorExtensions = {
+    classification?: string;
+    statusCode?: number;
+};
+export declare class UseQueryLightError extends Error {
+    networkError?: Error | null;
+    graphQLErrors?: ActualGraphQLError[];
+    extensions?: UseQueryLightErrorExtensions;
+    extraInfo?: any;
+    constructor(message: string, name?: string, graphQLErrors?: ActualGraphQLError[], networkError?: Error, extensions?: UseQueryLightErrorExtensions, extraInfo?: any);
+}
+export interface QueryResponse<TParams, TResult> extends QueryStatus<TResult> {
+    loading: boolean;
+    data?: TResult;
+    error?: UseQueryLightError;
+    refetch: () => void;
+    fetchMore: (args: FetchMoreArgs<TParams, TResult>) => void;
+}
+export interface QueryResult<TResult> {
+    data?: TResult;
+    extensions: {
+        errorNumber: number;
+    };
+    errors?: GraphQLError[];
+}
+export interface FetchMoreArgs<TParams, TResult> {
+    variables: Partial<TParams>;
+    handleDataMerge: (prevData: TResult | undefined, newData: TResult | undefined) => TResult | undefined;
+}
+export {};

package/dist/types/services/user-info-provider/index.d.ts

@@ -0,0 +1 @@
+export { userInfoProvider, UserInfoProvider } from './main';

package/dist/types/services/user-info-provider/main.d.ts

@@ -0,0 +1,14 @@
+interface UserInfo {
+    userId: string;
+    locale: string;
+    fullName: string;
+    avatarUrl: string;
+    email: string;
+    title: string;
+}
+export declare class UserInfoProvider {
+    private promise?;
+    get(fetchOp?: typeof fetch): Promise<UserInfo>;
+}
+export declare const userInfoProvider: UserInfoProvider;
+export {};

package/dist/types/services/user-preferences-client/index.d.ts

@@ -0,0 +1,9 @@
+import { type ReadMediaTokenResponse } from '../../types/media';
+import { RestClient } from '../rest-client';
+export declare class UserPreferencesClient extends RestClient {
+    getReadMediaToken(accountId: string): Promise<ReadMediaTokenResponse>;
+    getWriteMediaToken(): Promise<ReadMediaTokenResponse>;
+    updateUserHeaderImage(headerImageId: string | null): Promise<any>;
+}
+declare const _default: UserPreferencesClient;
+export default _default;

package/dist/types/types/config.d.ts

@@ -0,0 +1,7 @@
+export interface TeamsClientConfig {
+    stargateRoot: string;
+    permsServiceUrl: string;
+    publicApiRoot: string;
+    invitationsServiceUrl: string;
+    collaborationGraphUrl: string;
+}

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

@@ -0,0 +1,10 @@
+export type { TeamWithImageUrls, Team, TeamPermission, TeamsPermissionFromApi, TeamsPermissionApi, TeamRestriction, TeamMembershipSettings, ScopeMode, OrgScope, LinkedTeam, Scope, } from './team';
+export type { TeamsClientUser as User, EditableUserFields } from './user';
+export { isEditableUserField } from './user';
+export type { InvitedUser, TeamMembership, TeamAgentMembership, TeamWithMemberships, MembershipState, MembershipRole, } from './membership';
+export type { LinkOrder, NewTeamLink, TeamLink } from './links';
+export type { TeamsClientConfig } from './config';
+export { isResultWithPageInfo } from '../services/agg-client/types';
+export type { AGGPageInfo, ResultWithPageInfo, AGGPageInfoVariables, } from '../services/agg-client/types';
+export type { ReadMediaTokenResponse } from './media';
+export type { TeamInSlack } from './slack';

package/dist/types/types/links.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Used to synchronise these field names to forms used to create/edit links e.g. TeamLinkForm
+ */
+export declare const LINK_FIELDS: {
+    CONTENT_TITLE: "contentTitle";
+    DESCRIPTION: "description";
+    LINK_URI: "linkUri";
+};
+export interface TeamLink {
+    [LINK_FIELDS.CONTENT_TITLE]: string;
+    [LINK_FIELDS.DESCRIPTION]: string;
+    [LINK_FIELDS.LINK_URI]: string;
+    /**
+     * @private
+     * @deprecated field has been removed as part of migration to V4
+     */
+    creationTime?: string;
+    linkId: string;
+    teamId?: string;
+}
+/**
+ * Type for uncreated team links. These don't have link IDs
+ */
+export type NewTeamLink = Omit<TeamLink, 'linkId'>;
+/**
+ * Type for order of team links.
+ */
+export type LinkOrder = {
+    teamId: string;
+    linkOrder: string[];
+};

package/dist/types/types/media.d.ts

@@ -0,0 +1,6 @@
+export type ReadMediaTokenResponse = {
+    token?: string;
+    headerImageId: string;
+    baseUrl: string;
+    clientId: string;
+};

package/dist/types/types/membership.d.ts

@@ -0,0 +1,35 @@
+import { type TeamWithImageUrls } from './team';
+import { type TeamsClientUser } from './user';
+/**
+ * @private
+ * @deprecated INVITED is deprecated
+ */
+type DeprecratedMembershipState = 'INVITED';
+export type MembershipState = DeprecratedMembershipState | 'FULL_MEMBER' | 'ALUMNI' | 'REQUESTING_TO_JOIN';
+export type MembershipRole = 'REGULAR' | 'ADMIN';
+export type TeamMember = Pick<TeamsClientUser, 'id' | 'fullName' | 'avatarUrl' | 'status'>;
+type Membership<T> = {
+    membershipId: {
+        teamId: string;
+        memberId: string;
+    };
+    state: MembershipState;
+    role: MembershipRole;
+    user?: T;
+};
+/**
+ * @param membershipId - The team IDZ
+ */
+export type TeamMembership = Membership<TeamsClientUser>;
+export type TeamAgentMembership = Membership<TeamsClientUser>;
+export interface TeamWithMemberships extends TeamWithImageUrls {
+    members: TeamMember[];
+    includesYou: boolean;
+    memberCount: number;
+}
+export interface InvitedUser {
+    id: string | null;
+    email: string | null;
+}
+export declare function isTeamMembershipWithUser(membership: TeamMembership): membership is Required<TeamMembership>;
+export {};

package/dist/types/types/slack.d.ts

@@ -0,0 +1,7 @@
+export interface TeamInSlack {
+    id: string;
+    connected: boolean;
+    slackChannelId: string;
+    slackChannelName: string;
+    usergroupHandle: string;
+}