@forge/cli-shared 0.0.0-experimental-e05f7a2 → 0.0.0-experimental-d18f8dd

package/out/graphql/graphql-types.d.ts

@@ -13,6 +13,7 @@ export declare type Scalars = {
     AppStoredEntityFieldValue: any;
     CardPaletteColor: any;
     CardTypeHierarchyLevelType: any;
+    Date: any;
     DateTime: any;
     JSON: {
         [key: string]: any;
@@ -153,16 +154,6 @@ export declare type ActivitiesUser = {
     __typename?: 'ActivitiesUser';
     profile?: Maybe<User>;
 };
-export declare type ActivityConnection = {
-    __typename?: 'ActivityConnection';
-    nodes: Array<Maybe<ActivityItem>>;
-};
-export declare type ActivityContributor = {
-    __typename?: 'ActivityContributor';
-    profile?: Maybe<User>;
-    lastAccessedDate?: Maybe<Scalars['String']>;
-    count?: Maybe<Scalars['Int']>;
-};
 export declare type ActivityEdge = {
     __typename?: 'ActivityEdge';
     cursor: Scalars['String'];
@@ -180,54 +171,6 @@ export declare enum ActivityEventType {
     Published = "PUBLISHED",
     Edited = "EDITED"
 }
-export declare type ActivityFilter = {
-    aaIDs?: Maybe<Array<Maybe<Scalars['ID']>>>;
-    cloudIDs?: Maybe<Array<Maybe<Scalars['ID']>>>;
-    products?: Maybe<Array<Maybe<ActivityProduct>>>;
-    eventTypes?: Maybe<Array<Maybe<ActivityEventType>>>;
-    objectTypes?: Maybe<Array<Maybe<ActivityObjectType>>>;
-    transitions?: Maybe<Array<Maybe<ActivityTransition>>>;
-    containerIDs?: Maybe<Array<Maybe<Scalars['ID']>>>;
-    from?: Maybe<Scalars['String']>;
-    to?: Maybe<Scalars['String']>;
-    earliestStart?: Maybe<Scalars['String']>;
-    latestStart?: Maybe<Scalars['String']>;
-};
-export declare type ActivityHistory = {
-    __typename?: 'ActivityHistory';
-    actioner?: Maybe<User>;
-    eventType?: Maybe<ActivityEventType>;
-    timestamp?: Maybe<Scalars['String']>;
-};
-export declare type ActivityHistoryConnection = {
-    __typename?: 'ActivityHistoryConnection';
-    nodes: Array<Maybe<ActivityHistory>>;
-};
-export declare type ActivityItem = Node & {
-    __typename?: 'ActivityItem';
-    id: Scalars['ID'];
-    timestamp?: Maybe<Scalars['String']>;
-    eventType?: Maybe<ActivityEventType>;
-    object?: Maybe<ActivityObject>;
-    containers?: Maybe<Array<Maybe<ActivityObject>>>;
-    contributors?: Maybe<Array<Maybe<ActivityContributor>>>;
-};
-export declare type ActivityObject = Node & {
-    __typename?: 'ActivityObject';
-    id: Scalars['ID'];
-    localResourceId: Scalars['ID'];
-    name?: Maybe<Scalars['String']>;
-    type?: Maybe<ActivityObjectType>;
-    product?: Maybe<ActivityProduct>;
-    cloudID?: Maybe<Scalars['String']>;
-    url?: Maybe<Scalars['String']>;
-    iconURL?: Maybe<Scalars['String']>;
-    history?: Maybe<ActivityHistoryConnection>;
-};
-export declare type ActivityObjectConnection = {
-    __typename?: 'ActivityObjectConnection';
-    nodes: Array<Maybe<ActivityObject>>;
-};
 export declare enum ActivityObjectType {
     Site = "SITE",
     Project = "PROJECT",
@@ -451,6 +394,7 @@ export declare type AppEnvironmentVersionEdge = {
 };
 export declare type AppHostService = {
     __typename?: 'AppHostService';
+    serviceId: Scalars['ID'];
     name: Scalars['String'];
     description: Scalars['String'];
     scopes?: Maybe<Array<AppHostServiceScope>>;
@@ -593,6 +537,7 @@ export declare type AppLog = FunctionInvocationMetadata & Node & {
     installationContext?: Maybe<AppInstallationContext>;
     function?: Maybe<FunctionDescription>;
     trigger?: Maybe<FunctionTrigger>;
+    moduleType?: Maybe<Scalars['String']>;
     startTime?: Maybe<Scalars['String']>;
     appLogLines?: Maybe<AppLogLines>;
 };
@@ -813,12 +758,36 @@ export declare type ApplyPolarisProjectTemplatePayload = Payload & {
 };
 export declare type AppsFilter = {
     isPublishable?: Maybe<Scalars['Boolean']>;
+    migrationKey?: Maybe<Scalars['String']>;
 };
 export declare type ArchivePolarisInsightsPayload = Payload & {
     __typename?: 'ArchivePolarisInsightsPayload';
     success: Scalars['Boolean'];
     errors?: Maybe<Array<MutationError>>;
 };
+export declare type ArjConfiguration = {
+    __typename?: 'ArjConfiguration';
+    parentCustomFieldId?: Maybe<Scalars['String']>;
+    epicLinkCustomFieldId?: Maybe<Scalars['String']>;
+};
+export declare type ArjHierarchyConfigurationLevel = {
+    __typename?: 'ArjHierarchyConfigurationLevel';
+    issueTypes?: Maybe<Array<Scalars['String']>>;
+    title: Scalars['String'];
+};
+export declare type AssignIssueParentInput = {
+    boardId: Scalars['ID'];
+    issueIds: Array<Scalars['ID']>;
+    issueParentId: Scalars['ID'];
+};
+export declare type AssignIssueParentOutput = MutationResponse & {
+    __typename?: 'AssignIssueParentOutput';
+    boardScope?: Maybe<BoardScope>;
+    statusCode: Scalars['Int'];
+    success: Scalars['Boolean'];
+    message: Scalars['String'];
+    clientMutationId?: Maybe<Scalars['ID']>;
+};
 export declare type AtlassianAccountUser = User & LocalizationContext & {
     __typename?: 'AtlassianAccountUser';
     accountId: Scalars['ID'];
@@ -933,6 +902,9 @@ export declare type BacklogExtension = {
     __typename?: 'BacklogExtension';
     operations?: Maybe<Array<Maybe<SoftwareOperation>>>;
 };
+export declare enum BitbucketPermission {
+    Admin = "ADMIN"
+}
 export declare type BitbucketQuery = {
     __typename?: 'BitbucketQuery';
     bitbucketRepository?: Maybe<BitbucketRepository>;
@@ -1001,6 +973,14 @@ export declare type BitbucketWorkspace = Node & {
 export declare type BitbucketWorkspaceRepositoriesArgs = {
     first?: Maybe<Scalars['Int']>;
     after?: Maybe<Scalars['String']>;
+    permissionFilter?: Maybe<BitbucketPermission>;
+};
+export declare type BoardCardMoveInput = {
+    boardId?: Maybe<Scalars['ID']>;
+    cardIds?: Maybe<Array<Maybe<Scalars['ID']>>>;
+    swimlaneId?: Maybe<Scalars['ID']>;
+    transition?: Maybe<Scalars['ID']>;
+    rank?: Maybe<CardRank>;
 };
 export declare type BoardEditConfig = {
     __typename?: 'BoardEditConfig';
@@ -1076,6 +1056,7 @@ export declare type BoardScope = {
     currentUser: CurrentUser;
     sprint?: Maybe<Sprint>;
     customFilters?: Maybe<Array<Maybe<CustomFilter>>>;
+    filteredCardIds?: Maybe<Array<Maybe<Scalars['ID']>>>;
 };
 export declare type BoardScopeSprintsArgs = {
     state?: Maybe<Array<Maybe<SprintState>>>;
@@ -1086,12 +1067,32 @@ export declare type BoardScopeCardsArgs = {
 export declare type BoardScopeSprintArgs = {
     sprintId: Scalars['ID'];
 };
+export declare type BoardScopeFilteredCardIdsArgs = {
+    issueIds: Array<Maybe<Scalars['ID']>>;
+    customFilterIds: Array<Maybe<Scalars['ID']>>;
+};
 export declare enum BuiltinPolarisIdeaField {
+    Assignee = "ASSIGNEE",
+    Created = "CREATED",
+    Creator = "CREATOR",
+    Description = "DESCRIPTION",
+    IssueId = "ISSUE_ID",
+    IssueType = "ISSUE_TYPE",
     Key = "KEY",
+    Labels = "LABELS",
+    Reporter = "REPORTER",
+    Status = "STATUS",
     Summary = "SUMMARY",
-    Description = "DESCRIPTION",
-    Implementations = "IMPLEMENTATIONS",
-    Supports = "SUPPORTS"
+    Updated = "UPDATED",
+    Votes = "VOTES",
+    Archived = "ARCHIVED",
+    ArchivedBy = "ARCHIVED_BY",
+    ArchivedOn = "ARCHIVED_ON",
+    DeliveryProgress = "DELIVERY_PROGRESS",
+    DeliveryStatus = "DELIVERY_STATUS",
+    IssueComments = "ISSUE_COMMENTS",
+    LinkedIssues = "LINKED_ISSUES",
+    NumDataPoints = "NUM_DATA_POINTS"
 }
 export declare type BurndownChart = {
     __typename?: 'BurndownChart';
@@ -1200,12 +1201,20 @@ export declare type CardParent = {
     summary: Scalars['String'];
     cardType: CardType;
     color?: Maybe<Scalars['CardPaletteColor']>;
+    status?: Maybe<CardStatus>;
+    childrenInfo?: Maybe<SoftwareCardChildrenInfo>;
+    startDate?: Maybe<Scalars['String']>;
+    dueDate?: Maybe<Scalars['String']>;
 };
 export declare type CardPriority = {
     __typename?: 'CardPriority';
     name?: Maybe<Scalars['String']>;
     iconUrl?: Maybe<Scalars['String']>;
 };
+export declare type CardRank = {
+    afterCardId?: Maybe<Scalars['ID']>;
+    beforeCardId?: Maybe<Scalars['ID']>;
+};
 export declare type CardStatus = {
     __typename?: 'CardStatus';
     id?: Maybe<Scalars['ID']>;
@@ -1279,6 +1288,31 @@ export declare type ColumnStatus = {
     __typename?: 'ColumnStatus';
     transitions: Array<SoftwareCardTransition>;
     status: CardStatus;
+    cardTypeTransitions?: Maybe<Array<SoftwareCardTypeTransition>>;
+};
+export declare type CompassAcknowledgeAnnouncementInput = {
+    announcementId: Scalars['ID'];
+    componentId: Scalars['ID'];
+};
+export declare type CompassAcknowledgeAnnouncementPayload = Payload & {
+    __typename?: 'CompassAcknowledgeAnnouncementPayload';
+    acknowledgement?: Maybe<CompassAnnouncementAcknowledgement>;
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type CompassAnnouncement = {
+    __typename?: 'CompassAnnouncement';
+    id: Scalars['ID'];
+    component?: Maybe<CompassComponent>;
+    title?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    targetDate?: Maybe<Scalars['DateTime']>;
+    acknowledgements?: Maybe<Array<CompassAnnouncementAcknowledgement>>;
+};
+export declare type CompassAnnouncementAcknowledgement = {
+    __typename?: 'CompassAnnouncementAcknowledgement';
+    component?: Maybe<CompassComponent>;
+    hasAcknowledged?: Maybe<Scalars['Boolean']>;
 };
 export declare type CompassCatalogMutationApi = {
     __typename?: 'CompassCatalogMutationApi';
@@ -1306,11 +1340,20 @@ export declare type CompassCatalogMutationApi = {
     createScorecardCriterias?: Maybe<CreateCompassScorecardCriteriasPayload>;
     updateScorecardCriterias?: Maybe<UpdateCompassScorecardCriteriasPayload>;
     deleteScorecardCriterias?: Maybe<DeleteCompassScorecardCriteriasPayload>;
+    createAnnouncement?: Maybe<CompassCreateAnnouncementPayload>;
+    updateAnnouncement?: Maybe<CompassUpdateAnnouncementPayload>;
+    deleteAnnouncement?: Maybe<CompassDeleteAnnouncementPayload>;
+    acknowledgeAnnouncement?: Maybe<CompassAcknowledgeAnnouncementPayload>;
     createEventSource?: Maybe<CreateEventSourcePayload>;
     deleteEventSource?: Maybe<DeleteEventSourcePayload>;
-    createDeploymentEvents?: Maybe<CreateDeploymentEventsPayload>;
+    createDeploymentEvent?: Maybe<CreateDeploymentEventsPayload>;
     attachEventSource?: Maybe<AttachEventSourcePayload>;
     detachEventSource?: Maybe<DetachEventSourcePayload>;
+    createStarredComponent?: Maybe<CreateCompassStarredComponentPayload>;
+    deleteStarredComponent?: Maybe<DeleteCompassStarredComponentPayload>;
+    createTeamCheckin?: Maybe<CompassCreateTeamCheckinPayload>;
+    updateTeamCheckin?: Maybe<CompassUpdateTeamCheckinPayload>;
+    deleteTeamCheckin?: Maybe<CompassDeleteTeamCheckinPayload>;
 };
 export declare type CompassCatalogMutationApiCreateComponentArgs = {
     cloudId: Scalars['ID'];
@@ -1392,15 +1435,26 @@ export declare type CompassCatalogMutationApiDeleteScorecardCriteriasArgs = {
     scorecardId: Scalars['ID'];
     input: DeleteCompassScorecardCriteriasInput;
 };
+export declare type CompassCatalogMutationApiCreateAnnouncementArgs = {
+    input: CompassCreateAnnouncementInput;
+};
+export declare type CompassCatalogMutationApiUpdateAnnouncementArgs = {
+    input: CompassUpdateAnnouncementInput;
+};
+export declare type CompassCatalogMutationApiDeleteAnnouncementArgs = {
+    input: CompassDeleteAnnouncementInput;
+};
+export declare type CompassCatalogMutationApiAcknowledgeAnnouncementArgs = {
+    input: CompassAcknowledgeAnnouncementInput;
+};
 export declare type CompassCatalogMutationApiCreateEventSourceArgs = {
     input: CreateEventSourceInput;
 };
 export declare type CompassCatalogMutationApiDeleteEventSourceArgs = {
     input: DeleteEventSourceInput;
 };
-export declare type CompassCatalogMutationApiCreateDeploymentEventsArgs = {
-    input?: Maybe<Array<CreateDeploymentEventInput>>;
-    externalEventSourceId: Scalars['String'];
+export declare type CompassCatalogMutationApiCreateDeploymentEventArgs = {
+    input: CreateDeploymentEventInput;
 };
 export declare type CompassCatalogMutationApiAttachEventSourceArgs = {
     input: AttachEventSourceInput;
@@ -1408,14 +1462,34 @@ export declare type CompassCatalogMutationApiAttachEventSourceArgs = {
 export declare type CompassCatalogMutationApiDetachEventSourceArgs = {
     input: DetachEventSourceInput;
 };
+export declare type CompassCatalogMutationApiCreateStarredComponentArgs = {
+    cloudId: Scalars['ID'];
+    input: CreateCompassStarredComponentInput;
+};
+export declare type CompassCatalogMutationApiDeleteStarredComponentArgs = {
+    cloudId: Scalars['ID'];
+    input: DeleteCompassStarredComponentInput;
+};
+export declare type CompassCatalogMutationApiCreateTeamCheckinArgs = {
+    input: CompassCreateTeamCheckinInput;
+};
+export declare type CompassCatalogMutationApiUpdateTeamCheckinArgs = {
+    input: CompassUpdateTeamCheckinInput;
+};
+export declare type CompassCatalogMutationApiDeleteTeamCheckinArgs = {
+    input: CompassDeleteTeamCheckinInput;
+};
 export declare type CompassCatalogQueryApi = {
     __typename?: 'CompassCatalogQueryApi';
     component?: Maybe<CompassComponentResult>;
     componentByExternalAlias?: Maybe<CompassComponentResult>;
     fieldDefinitionsByComponentType?: Maybe<CompassFieldDefinitionsResult>;
     searchComponents?: Maybe<CompassComponentQueryResult>;
+    searchComponentLabels?: Maybe<CompassComponentLabelsQueryResult>;
     scorecard?: Maybe<CompassScorecardResult>;
     scorecards?: Maybe<CompassScorecardsQueryResult>;
+    starredComponents?: Maybe<CompassStarredComponentQueryResult>;
+    teamCheckins?: Maybe<Array<CompassTeamCheckin>>;
 };
 export declare type CompassCatalogQueryApiComponentArgs = {
     id: Scalars['ID'];
@@ -1433,6 +1507,10 @@ export declare type CompassCatalogQueryApiSearchComponentsArgs = {
     cloudId: Scalars['String'];
     query?: Maybe<CompassSearchComponentQuery>;
 };
+export declare type CompassCatalogQueryApiSearchComponentLabelsArgs = {
+    cloudId: Scalars['String'];
+    query?: Maybe<CompassSearchComponentLabelsQuery>;
+};
 export declare type CompassCatalogQueryApiScorecardArgs = {
     id: Scalars['ID'];
 };
@@ -1440,6 +1518,13 @@ export declare type CompassCatalogQueryApiScorecardsArgs = {
     cloudId: Scalars['ID'];
     query?: Maybe<CompassScorecardsQuery>;
 };
+export declare type CompassCatalogQueryApiStarredComponentsArgs = {
+    cloudId: Scalars['ID'];
+    query?: Maybe<CompassStarredComponentQuery>;
+};
+export declare type CompassCatalogQueryApiTeamCheckinsArgs = {
+    input: CompassTeamCheckinsInput;
+};
 export declare type CompassChangeMetadata = {
     __typename?: 'CompassChangeMetadata';
     createdAt?: Maybe<Scalars['DateTime']>;
@@ -1464,7 +1549,10 @@ export declare type CompassComponent = Node & {
     scorecards?: Maybe<Array<CompassScorecard>>;
     scorecardScores?: Maybe<Array<CompassScorecardScore>>;
     applicableScorecards?: Maybe<Array<CompassScorecard>>;
+    announcements?: Maybe<Array<CompassAnnouncement>>;
     events?: Maybe<CompassEventsQueryResult>;
+    eventSources?: Maybe<Array<EventSource>>;
+    scorecardScore?: Maybe<CompassScorecardScore>;
 };
 export declare type CompassComponentRelationshipsArgs = {
     query?: Maybe<CompassRelationshipQuery>;
@@ -1472,6 +1560,9 @@ export declare type CompassComponentRelationshipsArgs = {
 export declare type CompassComponentEventsArgs = {
     query?: Maybe<CompassEventsQuery>;
 };
+export declare type CompassComponentScorecardScoreArgs = {
+    query?: Maybe<CompassComponentScorecardScoreQuery>;
+};
 export declare type CompassComponentDataManager = {
     __typename?: 'CompassComponentDataManager';
     ecosystemAppId: Scalars['ID'];
@@ -1482,14 +1573,64 @@ export declare type CompassComponentLabel = {
     __typename?: 'CompassComponentLabel';
     name?: Maybe<Scalars['String']>;
 };
+export declare type CompassComponentLabelsQueryResult = CompassSearchComponentLabelsConnection | QueryError;
 export declare type CompassComponentQueryResult = CompassSearchComponentConnection | QueryError;
 export declare type CompassComponentResult = CompassComponent | QueryError;
+export declare type CompassComponentScorecardScoreQuery = {
+    scorecardId: Scalars['ID'];
+};
 export declare enum CompassComponentType {
     Application = "APPLICATION",
     Library = "LIBRARY",
     Service = "SERVICE",
     Other = "OTHER"
 }
+export declare type CompassCreateAnnouncementInput = {
+    componentId: Scalars['ID'];
+    title: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    targetDate: Scalars['DateTime'];
+};
+export declare type CompassCreateAnnouncementPayload = Payload & {
+    __typename?: 'CompassCreateAnnouncementPayload';
+    createdAnnouncement?: Maybe<CompassAnnouncement>;
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type CompassCreateTeamCheckinInput = {
+    cloudId: Scalars['ID'];
+    teamId: Scalars['ID'];
+    mood: Scalars['Int'];
+    response1?: Maybe<Scalars['String']>;
+    response2?: Maybe<Scalars['String']>;
+    response3?: Maybe<Scalars['String']>;
+};
+export declare type CompassCreateTeamCheckinPayload = Payload & {
+    __typename?: 'CompassCreateTeamCheckinPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    createdTeamCheckin?: Maybe<CompassTeamCheckin>;
+};
+export declare type CompassDeleteAnnouncementInput = {
+    cloudId: Scalars['ID'];
+    id: Scalars['ID'];
+};
+export declare type CompassDeleteAnnouncementPayload = Payload & {
+    __typename?: 'CompassDeleteAnnouncementPayload';
+    deletedAnnouncementId?: Maybe<Scalars['ID']>;
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type CompassDeleteTeamCheckinInput = {
+    cloudId: Scalars['ID'];
+    id: Scalars['ID'];
+};
+export declare type CompassDeleteTeamCheckinPayload = Payload & {
+    __typename?: 'CompassDeleteTeamCheckinPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    deletedTeamCheckinId?: Maybe<Scalars['ID']>;
+};
 export declare type CompassDeploymentEvent = CompassEvent & {
     __typename?: 'CompassDeploymentEvent';
     eventType: CompassEventType;
@@ -1507,6 +1648,7 @@ export declare type CompassDeploymentEventEnvironment = {
     __typename?: 'CompassDeploymentEventEnvironment';
     category?: Maybe<CompassDeploymentEventEnvironmentCategory>;
     displayName?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
 };
 export declare enum CompassDeploymentEventEnvironmentCategory {
     Production = "PRODUCTION",
@@ -1518,6 +1660,7 @@ export declare enum CompassDeploymentEventEnvironmentCategory {
 export declare type CompassDeploymentEventEnvironmentInput = {
     category: CompassDeploymentEventEnvironmentCategory;
     displayName: Scalars['String'];
+    environmentId: Scalars['String'];
 };
 export declare type CompassDeploymentEventPipeline = {
     __typename?: 'CompassDeploymentEventPipeline';
@@ -1561,9 +1704,15 @@ export declare type CompassEvent = {
 };
 export declare type CompassEventConnection = {
     __typename?: 'CompassEventConnection';
+    edges?: Maybe<Array<Maybe<CompassEventEdge>>>;
     nodes?: Maybe<Array<CompassEvent>>;
     pageInfo: PageInfo;
 };
+export declare type CompassEventEdge = {
+    __typename?: 'CompassEventEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<CompassEvent>;
+};
 export declare type CompassEventTimeParameters = {
     startFrom?: Maybe<Scalars['DateTime']>;
     endAt?: Maybe<Scalars['DateTime']>;
@@ -1724,11 +1873,31 @@ export declare type CompassScorecard = Node & {
     componentType: CompassComponentType;
     importance: CompassScorecardImportance;
     scorecardScore?: Maybe<CompassScorecardScore>;
+    appliedToComponents?: Maybe<CompassScorecardAppliedToComponentsQueryResult>;
     changeMetadata: CompassChangeMetadata;
 };
 export declare type CompassScorecardScorecardScoreArgs = {
     query?: Maybe<CompassScorecardScoreQuery>;
 };
+export declare type CompassScorecardAppliedToComponentsArgs = {
+    query?: Maybe<CompassScorecardAppliedToComponentsQuery>;
+};
+export declare type CompassScorecardAppliedToComponentsConnection = {
+    __typename?: 'CompassScorecardAppliedToComponentsConnection';
+    edges?: Maybe<Array<CompassScorecardAppliedToComponentsEdge>>;
+    nodes?: Maybe<Array<CompassComponent>>;
+    pageInfo: PageInfo;
+};
+export declare type CompassScorecardAppliedToComponentsEdge = {
+    __typename?: 'CompassScorecardAppliedToComponentsEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<CompassComponent>;
+};
+export declare type CompassScorecardAppliedToComponentsQuery = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+};
+export declare type CompassScorecardAppliedToComponentsQueryResult = CompassScorecardAppliedToComponentsConnection | QueryError;
 export declare type CompassScorecardConnection = {
     __typename?: 'CompassScorecardConnection';
     edges?: Maybe<Array<CompassScorecardEdge>>;
@@ -1789,6 +1958,23 @@ export declare type CompassSearchComponentEdge = {
     cursor: Scalars['String'];
     node?: Maybe<CompassSearchComponentResult>;
 };
+export declare type CompassSearchComponentLabelsConnection = {
+    __typename?: 'CompassSearchComponentLabelsConnection';
+    edges?: Maybe<Array<CompassSearchComponentLabelsEdge>>;
+    nodes?: Maybe<Array<CompassComponentLabel>>;
+    pageInfo: PageInfo;
+};
+export declare type CompassSearchComponentLabelsEdge = {
+    __typename?: 'CompassSearchComponentLabelsEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<CompassComponentLabel>;
+};
+export declare type CompassSearchComponentLabelsQuery = {
+    query?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    sort?: Maybe<Array<Maybe<CompassQuerySort>>>;
+};
 export declare type CompassSearchComponentQuery = {
     query?: Maybe<Scalars['String']>;
     first?: Maybe<Scalars['Int']>;
@@ -1801,6 +1987,64 @@ export declare type CompassSearchComponentResult = {
     component?: Maybe<CompassComponent>;
     link: Scalars['URL'];
 };
+export declare type CompassStarredComponentConnection = {
+    __typename?: 'CompassStarredComponentConnection';
+    nodes?: Maybe<Array<CompassComponent>>;
+    edges?: Maybe<Array<CompassStarredComponentEdge>>;
+    pageInfo: PageInfo;
+};
+export declare type CompassStarredComponentEdge = {
+    __typename?: 'CompassStarredComponentEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<CompassComponent>;
+};
+export declare type CompassStarredComponentQuery = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+};
+export declare type CompassStarredComponentQueryResult = CompassStarredComponentConnection | QueryError;
+export declare type CompassTeamCheckin = {
+    __typename?: 'CompassTeamCheckin';
+    teamId?: Maybe<Scalars['ID']>;
+    id: Scalars['ID'];
+    mood?: Maybe<Scalars['Int']>;
+    response1?: Maybe<Scalars['String']>;
+    response2?: Maybe<Scalars['String']>;
+    response3?: Maybe<Scalars['String']>;
+    changeMetadata: CompassChangeMetadata;
+};
+export declare type CompassTeamCheckinsInput = {
+    cloudId: Scalars['ID'];
+    teamId: Scalars['ID'];
+};
+export declare type CompassUpdateAnnouncementInput = {
+    cloudId: Scalars['ID'];
+    id: Scalars['ID'];
+    title?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    targetDate?: Maybe<Scalars['DateTime']>;
+    clearAcknowledgements?: Maybe<Scalars['Boolean']>;
+};
+export declare type CompassUpdateAnnouncementPayload = Payload & {
+    __typename?: 'CompassUpdateAnnouncementPayload';
+    updatedAnnouncement?: Maybe<CompassAnnouncement>;
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type CompassUpdateTeamCheckinInput = {
+    cloudId: Scalars['ID'];
+    id: Scalars['ID'];
+    mood: Scalars['Int'];
+    response1?: Maybe<Scalars['String']>;
+    response2?: Maybe<Scalars['String']>;
+    response3?: Maybe<Scalars['String']>;
+};
+export declare type CompassUpdateTeamCheckinPayload = Payload & {
+    __typename?: 'CompassUpdateTeamCheckinPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    updatedTeamCheckin?: Maybe<CompassTeamCheckin>;
+};
 export declare type CompatibleAtlassianCloudProduct = CompatibleAtlassianProduct & {
     __typename?: 'CompatibleAtlassianCloudProduct';
     id: Scalars['ID'];
@@ -2059,6 +2303,15 @@ export declare type CreateCompassScorecardPayload = Payload & {
     errors?: Maybe<Array<MutationError>>;
     scorecardDetails?: Maybe<CompassScorecard>;
 };
+export declare type CreateCompassStarredComponentInput = {
+    id: Scalars['ID'];
+};
+export declare type CreateCompassStarredComponentPayload = Payload & {
+    __typename?: 'CreateCompassStarredComponentPayload';
+    components?: Maybe<CompassStarredComponentConnection>;
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
 export declare type CreateCustomFilterInput = {
     boardId: Scalars['ID'];
     name: Scalars['String'];
@@ -2066,6 +2319,7 @@ export declare type CreateCustomFilterInput = {
     description?: Maybe<Scalars['String']>;
 };
 export declare type CreateDeploymentEventInput = {
+    cloudId: Scalars['ID'];
     deploymentSequenceNumber: Scalars['Long'];
     updateSequenceNumber: Scalars['Long'];
     displayName: Scalars['String'];
@@ -2154,7 +2408,7 @@ export declare type CreateEventSourceInput = {
 };
 export declare type CreateEventSourcePayload = Payload & {
     __typename?: 'CreateEventSourcePayload';
-    eventSourceId?: Maybe<Scalars['ID']>;
+    eventSource?: Maybe<EventSource>;
     success: Scalars['Boolean'];
     errors?: Maybe<Array<MutationError>>;
 };
@@ -2235,6 +2489,10 @@ export declare type CreatePolarisDecorationPayload = Payload & {
     errors?: Maybe<Array<MutationError>>;
     node?: Maybe<PolarisDecoration>;
 };
+export declare type CreatePolarisInsightFromPlayContributionInput = {
+    contribution: Scalars['ID'];
+    subject?: Maybe<Scalars['ID']>;
+};
 export declare type CreatePolarisInsightInput = {
     cloudID: Scalars['String'];
     projectID: Scalars['Int'];
@@ -2249,6 +2507,33 @@ export declare type CreatePolarisInsightPayload = Payload & {
     errors?: Maybe<Array<MutationError>>;
     node?: Maybe<PolarisInsight>;
 };
+export declare type CreatePolarisPlayContribution = {
+    play: Scalars['ID'];
+    subject: Scalars['ID'];
+    amount?: Maybe<Scalars['Int']>;
+    comment?: Maybe<Scalars['JSON']>;
+};
+export declare type CreatePolarisPlayContributionPayload = {
+    __typename?: 'CreatePolarisPlayContributionPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    node?: Maybe<PolarisPlayContribution>;
+};
+export declare type CreatePolarisPlayInput = {
+    project: Scalars['ID'];
+    kind: PolarisPlayKind;
+    label: Scalars['String'];
+    summary?: Maybe<Scalars['String']>;
+    parameters?: Maybe<Scalars['JSON']>;
+    fromView?: Maybe<Scalars['ID']>;
+    description?: Maybe<Scalars['JSON']>;
+};
+export declare type CreatePolarisPlayPayload = {
+    __typename?: 'CreatePolarisPlayPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    node?: Maybe<PolarisPlay>;
+};
 export declare type CreatePolarisProjectInput = {
     tenant: Scalars['ID'];
     key: Scalars['String'];
@@ -2354,6 +2639,12 @@ export declare type CustomFilterCreateOutput = MutationResponse & {
     success: Scalars['Boolean'];
     message: Scalars['String'];
     customFilter?: Maybe<CustomFilter>;
+    validationErrors: Array<CustomFiltersValidationError>;
+};
+export declare type CustomFiltersValidationError = {
+    __typename?: 'CustomFiltersValidationError';
+    fieldName: Scalars['String'];
+    errorMessage: Scalars['String'];
 };
 export declare type CustomUiTunnelDefinition = {
     __typename?: 'CustomUITunnelDefinition';
@@ -2393,6 +2684,7 @@ export declare type DeleteAppResponse = Payload & {
 export declare type DeleteAppStoredEntityMutationInput = {
     key: Scalars['ID'];
     contextAri: Scalars['ID'];
+    encrypted?: Maybe<Scalars['Boolean']>;
 };
 export declare type DeleteAppStoredEntityPayload = Payload & {
     __typename?: 'DeleteAppStoredEntityPayload';
@@ -2473,6 +2765,15 @@ export declare type DeleteCompassScorecardPayload = Payload & {
     errors?: Maybe<Array<MutationError>>;
     scorecardId: Scalars['ID'];
 };
+export declare type DeleteCompassStarredComponentInput = {
+    id: Scalars['ID'];
+};
+export declare type DeleteCompassStarredComponentPayload = Payload & {
+    __typename?: 'DeleteCompassStarredComponentPayload';
+    components?: Maybe<CompassStarredComponentConnection>;
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
 export declare type DeleteCustomFilterInput = {
     boardId: Scalars['ID'];
     customFilterId: Scalars['String'];
@@ -2596,6 +2897,11 @@ export declare type DeletePolarisInsightPayload = Payload & {
     success: Scalars['Boolean'];
     errors?: Maybe<Array<MutationError>>;
 };
+export declare type DeletePolarisPlayContributionPayload = {
+    __typename?: 'DeletePolarisPlayContributionPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
 export declare type DeletePolarisViewPayload = Payload & {
     __typename?: 'DeletePolarisViewPayload';
     success: Scalars['Boolean'];
@@ -2610,6 +2916,14 @@ export declare type DeleteSprintInput = {
     boardId: Scalars['ID'];
     sprintId: Scalars['ID'];
 };
+export declare type DeleteUserGrantInput = {
+    oauthClientId: Scalars['ID'];
+};
+export declare type DeleteUserGrantPayload = Payload & {
+    __typename?: 'DeleteUserGrantPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
 export declare type DeleteWebTriggerUrlResponse = MutationResponse & {
     __typename?: 'DeleteWebTriggerUrlResponse';
     statusCode: Scalars['Int'];
@@ -2634,6 +2948,7 @@ export declare type DeploymentSummary = Node & {
     __typename?: 'DeploymentSummary';
     id: Scalars['ID'];
     issueIds?: Maybe<Array<Scalars['ID']>>;
+    provider?: Maybe<DevOpsProvider>;
     deploymentSequenceNumber?: Maybe<Scalars['Long']>;
     updateSequenceNumber?: Maybe<Scalars['Long']>;
     displayName?: Maybe<Scalars['String']>;
@@ -2861,6 +3176,18 @@ export declare type DevOpsMetricsRollupType = {
     type: DevOpsMetricsRollupOption;
     percentile?: Maybe<Scalars['Int']>;
 };
+export declare type DevOpsProvider = {
+    __typename?: 'DevOpsProvider';
+    name?: Maybe<Scalars['String']>;
+    links?: Maybe<DevOpsProviderLinks>;
+    logo?: Maybe<Scalars['URL']>;
+};
+export declare type DevOpsProviderLinks = {
+    __typename?: 'DevOpsProviderLinks';
+    documentation?: Maybe<Scalars['URL']>;
+    home?: Maybe<Scalars['URL']>;
+    listDeploymentsTemplate?: Maybe<Scalars['URL']>;
+};
 export declare enum DevOpsRelationshipCertainty {
     Explicit = "EXPLICIT",
     Implicit = "IMPLICIT"
@@ -3129,6 +3456,11 @@ export declare enum DevStatusActivity {
     BranchOpen = "BRANCH_OPEN",
     Commit = "COMMIT"
 }
+export declare type DeveloperLogAccessResult = {
+    __typename?: 'DeveloperLogAccessResult';
+    developerHasAccess: Scalars['Boolean'];
+    contextId: Scalars['ID'];
+};
 export declare type DvcsBitbucketWorkspaceConnection = {
     __typename?: 'DvcsBitbucketWorkspaceConnection';
     edges?: Maybe<Array<Maybe<DvcsBitbucketWorkspaceEdge>>>;
@@ -3149,13 +3481,34 @@ export declare type DvcsQueryBitbucketWorkspacesLinkedToSiteArgs = {
     first?: Maybe<Scalars['Int']>;
     after?: Maybe<Scalars['String']>;
 };
+export declare type EcosystemMutation = {
+    __typename?: 'EcosystemMutation';
+    updateAppHostServiceScopes?: Maybe<UpdateAppHostServiceScopesResponsePayload>;
+    deleteUserGrant?: Maybe<DeleteUserGrantPayload>;
+};
+export declare type EcosystemMutationUpdateAppHostServiceScopesArgs = {
+    input: UpdateAppHostServiceScopesInput;
+};
+export declare type EcosystemMutationDeleteUserGrantArgs = {
+    input: DeleteUserGrantInput;
+};
+export declare type EcosystemQuery = {
+    __typename?: 'EcosystemQuery';
+    userGrants?: Maybe<UserGrantConnection>;
+};
+export declare type EcosystemQueryUserGrantsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    after?: Maybe<Scalars['String']>;
+};
 export declare type EditSprintInput = {
     boardId: Scalars['ID'];
     sprintId: Scalars['ID'];
     name?: Maybe<Scalars['String']>;
     goal?: Maybe<Scalars['String']>;
-    startDate?: Maybe<Scalars['DateTime']>;
-    endDate?: Maybe<Scalars['DateTime']>;
+    startDate?: Maybe<Scalars['String']>;
+    endDate?: Maybe<Scalars['String']>;
 };
 export declare enum EpicView {
     All = "ALL",
@@ -3178,6 +3531,22 @@ export declare type EstimationConfig = {
     current: CurrentEstimation;
     available: Array<AvailableEstimations>;
 };
+export declare enum EventKnownAvIs {
+    AviJiraIssueCreated = "AVI_JIRA_ISSUE_CREATED",
+    AviJiraIssueUpdated = "AVI_JIRA_ISSUE_UPDATED",
+    AviBitbucketPrCreated = "AVI_BITBUCKET_PR_CREATED"
+}
+export declare enum EventMatchingStrategies {
+    JiraByProject = "JIRA_BY_PROJECT",
+    JiraByIssue = "JIRA_BY_ISSUE",
+    BitbucketByRepo = "BITBUCKET_BY_REPO"
+}
+export declare type EventSource = {
+    __typename?: 'EventSource';
+    id: Scalars['ID'];
+    externalEventSourceId: Scalars['ID'];
+    eventType: CompassEventType;
+};
 export declare type Extension = {
     __typename?: 'Extension';
     id: Scalars['ID'];
@@ -3243,6 +3612,7 @@ export declare type FunctionInvocationMetadata = {
     installationContext?: Maybe<AppInstallationContext>;
     function?: Maybe<FunctionDescription>;
     trigger?: Maybe<FunctionTrigger>;
+    moduleType?: Maybe<Scalars['String']>;
 };
 export declare type FunctionTrigger = {
     __typename?: 'FunctionTrigger';
@@ -3294,6 +3664,11 @@ export declare type InlineColumnEditConfig = {
     __typename?: 'InlineColumnEditConfig';
     enabled: Scalars['Boolean'];
 };
+export declare type InstallationContextWithLogAccess = {
+    __typename?: 'InstallationContextWithLogAccess';
+    installationContext: Scalars['ID'];
+    tenantContext?: Maybe<TenantContext>;
+};
 export declare type InvocationResponsePayload = {
     __typename?: 'InvocationResponsePayload';
     body: Scalars['JSON'];
@@ -3322,6 +3697,16 @@ export declare type InvokeExtensionInput = {
     entryPoint?: Maybe<Scalars['String']>;
     schema?: Maybe<Scalars['String']>;
 };
+export declare type InvokeExtensionPayloadErrorExtension = MutationErrorExtension & {
+    __typename?: 'InvokeExtensionPayloadErrorExtension';
+    errorType?: Maybe<Scalars['String']>;
+    statusCode?: Maybe<Scalars['Int']>;
+    fields?: Maybe<InvokeExtensionPayloadErrorExtensionFields>;
+};
+export declare type InvokeExtensionPayloadErrorExtensionFields = {
+    __typename?: 'InvokeExtensionPayloadErrorExtensionFields';
+    authInfoUrl?: Maybe<Scalars['String']>;
+};
 export declare type InvokeExtensionResponse = MutationResponse & Payload & {
     __typename?: 'InvokeExtensionResponse';
     statusCode: Scalars['Int'];
@@ -3656,41 +4041,1717 @@ export declare type IssueDevOpsTestSummary = {
     numberFailed?: Maybe<Scalars['Int']>;
     numberSkipped?: Maybe<Scalars['Int']>;
 };
-export declare type JiraAvatar = {
-    __typename?: 'JiraAvatar';
-    xsmall?: Maybe<Scalars['String']>;
-    small?: Maybe<Scalars['String']>;
-    medium?: Maybe<Scalars['String']>;
-    large?: Maybe<Scalars['String']>;
+export declare type JiraAdf = {
+    __typename?: 'JiraADF';
+    json?: Maybe<Scalars['JSON']>;
 };
-export declare type JiraIssueType = Node & {
-    __typename?: 'JiraIssueType';
+export declare type JiraAffectedService = {
+    __typename?: 'JiraAffectedService';
+    serviceId?: Maybe<Scalars['String']>;
+};
+export declare type JiraAffectedServiceConnection = {
+    __typename?: 'JiraAffectedServiceConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraAffectedServiceEdge>>>;
+};
+export declare type JiraAffectedServiceEdge = {
+    __typename?: 'JiraAffectedServiceEdge';
+    node?: Maybe<JiraAffectedService>;
+    cursor: Scalars['String'];
+};
+export declare type JiraAffectedServicesField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraAffectedServicesField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedAffectedServices?: Maybe<Array<Maybe<JiraAffectedService>>>;
+    affectedServices?: Maybe<JiraAffectedServiceConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraAffectedServicesFieldAffectedServicesArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraAsset = {
+    __typename?: 'JiraAsset';
+    appKey?: Maybe<Scalars['String']>;
+    originId?: Maybe<Scalars['String']>;
+    serializedOrigin?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
+};
+export declare type JiraAssetField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraAssetField';
     id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
     name: Scalars['String'];
     description?: Maybe<Scalars['String']>;
+    selectedAssets?: Maybe<Array<Maybe<JiraAsset>>>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraAtlassianTeam = {
+    __typename?: 'JiraAtlassianTeam';
+    teamId?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
     avatar?: Maybe<JiraAvatar>;
 };
-export declare type JiraIssueTypeConnection = {
-    __typename?: 'JiraIssueTypeConnection';
-    pageInfo: JiraProjectsPageInfo;
-    edges?: Maybe<Array<Maybe<JiraIssueTypeEdge>>>;
+export declare type JiraAtlassianTeamConnection = {
+    __typename?: 'JiraAtlassianTeamConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraAtlassianTeamEdge>>>;
 };
-export declare type JiraIssueTypeEdge = {
-    __typename?: 'JiraIssueTypeEdge';
-    node?: Maybe<JiraIssueType>;
+export declare type JiraAtlassianTeamEdge = {
+    __typename?: 'JiraAtlassianTeamEdge';
+    node?: Maybe<JiraAtlassianTeam>;
     cursor: Scalars['String'];
 };
-export declare type JiraProject = Node & {
-    __typename?: 'JiraProject';
+export declare type JiraAtlassianTeamField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraAtlassianTeamField';
     id: Scalars['ID'];
-    key: Scalars['String'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
     name: Scalars['String'];
-    cloudId: Scalars['ID'];
     description?: Maybe<Scalars['String']>;
-    leadId?: Maybe<Scalars['ID']>;
-    category?: Maybe<JiraProjectCategory>;
-    avatar?: Maybe<JiraAvatar>;
-    projectUrl?: Maybe<Scalars['String']>;
+    selectedTeam?: Maybe<JiraAtlassianTeam>;
+    teams?: Maybe<JiraAtlassianTeamConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraAtlassianTeamFieldTeamsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraAttachment = {
+    __typename?: 'JiraAttachment';
+    id: Scalars['ID'];
+    mediaApiFileId?: Maybe<Scalars['String']>;
+    createdDate?: Maybe<Scalars['DateTime']>;
+    mimetype?: Maybe<Scalars['String']>;
+    filename?: Maybe<Scalars['String']>;
+    filesize?: Maybe<Scalars['Int']>;
+};
+export declare type JiraAttachmentConnection = {
+    __typename?: 'JiraAttachmentConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraAttachmentEdge>>>;
+};
+export declare type JiraAttachmentEdge = {
+    __typename?: 'JiraAttachmentEdge';
+    node?: Maybe<JiraAttachment>;
+    cursor: Scalars['String'];
+};
+export declare type JiraAttachmentsField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraAttachmentsField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    permissions?: Maybe<Array<Maybe<JiraAttachmentsPermissions>>>;
+    attachments?: Maybe<JiraAttachmentConnection>;
+    maxAllowedTotalAttachmentsSize?: Maybe<Scalars['Long']>;
+    mediaContext?: Maybe<JiraMediaContext>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraAttachmentsFieldAttachmentsArgs = {
+    startAt?: Maybe<Scalars['Int']>;
+    maxResults?: Maybe<Scalars['Int']>;
+    orderField?: Maybe<JiraAttachmentsOrderField>;
+    orderDirection?: Maybe<JiraOrderDirection>;
+};
+export declare type JiraAttachmentsOrderField = {
+    id: Scalars['ID'];
+};
+export declare enum JiraAttachmentsPermissions {
+    CreateAttachments = "CREATE_ATTACHMENTS",
+    DeleteOwnAttachments = "DELETE_OWN_ATTACHMENTS"
+}
+export declare type JiraAvatar = {
+    __typename?: 'JiraAvatar';
+    xsmall?: Maybe<Scalars['String']>;
+    small?: Maybe<Scalars['String']>;
+    medium?: Maybe<Scalars['String']>;
+    large?: Maybe<Scalars['String']>;
+};
+export declare type JiraCmdbField = JiraIssueField & JiraIssueFieldConfiguration & {
+    __typename?: 'JiraCMDBField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    isMulti?: Maybe<Scalars['Boolean']>;
+    searchUrl?: Maybe<Scalars['String']>;
+    selectedCmdbObjects?: Maybe<Array<Maybe<JiraCmdbObject>>>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+    attributesIncludedInAutoCompleteSearch?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export declare type JiraCascadingOption = {
+    __typename?: 'JiraCascadingOption';
+    parentOptionValue?: Maybe<JiraOption>;
+    childOptionValue?: Maybe<JiraOption>;
+};
+export declare type JiraCascadingOptions = {
+    __typename?: 'JiraCascadingOptions';
+    parentOptionValue?: Maybe<JiraOption>;
+    childOptionValues?: Maybe<Array<Maybe<JiraOption>>>;
+};
+export declare type JiraCascadingOptionsConnection = {
+    __typename?: 'JiraCascadingOptionsConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraCascadingOptionsEdge>>>;
+};
+export declare type JiraCascadingOptionsEdge = {
+    __typename?: 'JiraCascadingOptionsEdge';
+    node?: Maybe<JiraCascadingOptions>;
+    cursor: Scalars['String'];
+};
+export declare type JiraCascadingSelectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraCascadingSelectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    cascadingOption?: Maybe<JiraCascadingOption>;
+    cascadingOptions?: Maybe<JiraCascadingOptionsConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraCascadingSelectFieldCascadingOptionsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare enum JiraCascadingSelectOptionType {
+    Parent = "PARENT",
+    Child = "CHILD",
+    All = "ALL"
+}
+export declare type JiraCascadingSelectOptionsFilter = {
+    optionType: JiraCascadingSelectOptionType;
+    parentOptionName?: Maybe<Scalars['String']>;
+};
+export declare type JiraCheckboxesField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraCheckboxesField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedFieldOptions?: Maybe<Array<Maybe<JiraOption>>>;
+    fieldOptions?: Maybe<JiraOptionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraCheckboxesFieldFieldOptionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraCmdbObject = Node & {
+    __typename?: 'JiraCmdbObject';
+    id: Scalars['ID'];
+    objectGlobalId?: Maybe<Scalars['String']>;
+    objectId?: Maybe<Scalars['String']>;
+    workspaceId?: Maybe<Scalars['String']>;
+    label?: Maybe<Scalars['String']>;
+};
+export declare type JiraColor = {
+    __typename?: 'JiraColor';
+    id?: Maybe<Scalars['ID']>;
+    colorKey?: Maybe<Scalars['String']>;
+};
+export declare type JiraColorField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraColorField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    color?: Maybe<JiraColor>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraComponent = Node & {
+    __typename?: 'JiraComponent';
+    id: Scalars['ID'];
+    componentId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+};
+export declare type JiraComponentConnection = {
+    __typename?: 'JiraComponentConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraComponentEdge>>>;
+};
+export declare type JiraComponentEdge = {
+    __typename?: 'JiraComponentEdge';
+    node?: Maybe<JiraComponent>;
+    cursor: Scalars['String'];
+};
+export declare type JiraComponentsField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraComponentsField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedComponents?: Maybe<Array<Maybe<JiraComponent>>>;
+    components?: Maybe<JiraComponentConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraComponentsFieldComponentsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraConnectMultipleSelectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraConnectMultipleSelectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedFieldOptions?: Maybe<Array<Maybe<JiraOption>>>;
+    fieldOptions?: Maybe<JiraOptionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraConnectMultipleSelectFieldFieldOptionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraConnectNumberField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraConnectNumberField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    number?: Maybe<Scalars['Float']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraConnectRichTextField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraConnectRichTextField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    richText?: Maybe<JiraRichText>;
+    renderer?: Maybe<Scalars['String']>;
+    mediaContext?: Maybe<JiraMediaContext>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraConnectSingleSelectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraConnectSingleSelectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    fieldOption?: Maybe<JiraOption>;
+    fieldOptions?: Maybe<JiraOptionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraConnectSingleSelectFieldFieldOptionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraConnectTextField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraConnectTextField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    text?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraDatePickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraDatePickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    date?: Maybe<Scalars['Date']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraDateTimePickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraDateTimePickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    dateTime?: Maybe<Scalars['DateTime']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraDefaultGrantTypeValue = Node & {
+    __typename?: 'JiraDefaultGrantTypeValue';
+    id: Scalars['ID'];
+    name: Scalars['String'];
+};
+export declare type JiraDevOpsIssuePanel = {
+    __typename?: 'JiraDevOpsIssuePanel';
+    panelState?: Maybe<JiraDevOpsIssuePanelState>;
+    devOpsIssuePanelBanner?: Maybe<JiraDevOpsIssuePanelBannerType>;
+    devSummaryResult?: Maybe<JiraIssueDevSummaryResult>;
+};
+export declare enum JiraDevOpsIssuePanelBannerType {
+    IssueKeyOnboarding = "ISSUE_KEY_ONBOARDING"
+}
+export declare enum JiraDevOpsIssuePanelState {
+    Hidden = "HIDDEN",
+    NotConnected = "NOT_CONNECTED",
+    DevSummary = "DEV_SUMMARY"
+}
+export declare type JiraDevOpsMutation = {
+    __typename?: 'JiraDevOpsMutation';
+    optoutOfDevOpsIssuePanelNotConnectedState?: Maybe<JiraOptoutDevOpsIssuePanelNotConnectedPayload>;
+    dismissDevOpsIssuePanelBanner?: Maybe<JiraDismissDevOpsIssuePanelBannerPayload>;
+};
+export declare type JiraDevOpsMutationDismissDevOpsIssuePanelBannerArgs = {
+    input: JiraDismissDevOpsIssuePanelBannerInput;
+};
+export declare type JiraDevOpsQuery = {
+    __typename?: 'JiraDevOpsQuery';
+    devOpsIssuePanel?: Maybe<JiraDevOpsIssuePanel>;
+};
+export declare type JiraDevOpsQueryDevOpsIssuePanelArgs = {
+    issueId: Scalars['ID'];
+};
+export declare type JiraDismissDevOpsIssuePanelBannerInput = {
+    issueId: Scalars['ID'];
+    bannerType: JiraDevOpsIssuePanelBannerType;
+};
+export declare type JiraDismissDevOpsIssuePanelBannerPayload = Payload & {
+    __typename?: 'JiraDismissDevOpsIssuePanelBannerPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type JiraEpic = {
+    __typename?: 'JiraEpic';
+    id: Scalars['ID'];
+    issueId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    key?: Maybe<Scalars['String']>;
+    summary?: Maybe<Scalars['String']>;
+    color?: Maybe<Scalars['String']>;
+    done?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraEpicConnection = {
+    __typename?: 'JiraEpicConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraEpicEdge>>>;
+};
+export declare type JiraEpicEdge = {
+    __typename?: 'JiraEpicEdge';
+    node?: Maybe<JiraEpic>;
+    cursor: Scalars['String'];
+};
+export declare type JiraEpicLinkField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraEpicLinkField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    epic?: Maybe<JiraEpic>;
+    epics?: Maybe<JiraEpicConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraEpicLinkFieldEpicsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    done?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraEstimate = {
+    __typename?: 'JiraEstimate';
+    timeInSeconds?: Maybe<Scalars['Long']>;
+};
+export declare type JiraFieldConfig = {
+    __typename?: 'JiraFieldConfig';
+    isRequired?: Maybe<Scalars['Boolean']>;
+    isEditable?: Maybe<Scalars['Boolean']>;
+    nonEditableReason?: Maybe<JiraFieldNonEditableReason>;
+};
+export declare type JiraFieldNonEditableReason = {
+    __typename?: 'JiraFieldNonEditableReason';
+    message?: Maybe<Scalars['String']>;
+};
+export declare type JiraFlag = {
+    __typename?: 'JiraFlag';
+    isFlagged?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraFlagField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraFlagField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    flag?: Maybe<JiraFlag>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraForgeGroupField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraForgeGroupField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedGroup?: Maybe<JiraGroup>;
+    groups?: Maybe<JiraGroupConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraForgeGroupFieldGroupsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraForgeNumberField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraForgeNumberField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    number?: Maybe<Scalars['Float']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraForgeStringField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraForgeStringField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    text?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraForgeStringsField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraForgeStringsField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedLabels?: Maybe<Array<Maybe<JiraLabel>>>;
+    labels?: Maybe<JiraLabelConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraForgeStringsFieldLabelsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraForgeUserField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraForgeUserField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    user?: Maybe<User>;
+    users?: Maybe<JiraUserConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraForgeUserFieldUsersArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraGrantTypeKey = {
+    __typename?: 'JiraGrantTypeKey';
+    key: JiraGrantTypeKeyEnum;
+    name: Scalars['String'];
+};
+export declare enum JiraGrantTypeKeyEnum {
+    ProjectRole = "PROJECT_ROLE",
+    ApplicationRole = "APPLICATION_ROLE",
+    User = "USER",
+    Group = "GROUP",
+    MultiUserPicker = "MULTI_USER_PICKER",
+    MultiGroupPicker = "MULTI_GROUP_PICKER",
+    ServiceProjectCustomerPortalAccess = "SERVICE_PROJECT_CUSTOMER_PORTAL_ACCESS",
+    Reporter = "REPORTER",
+    ProjectLead = "PROJECT_LEAD",
+    Assignee = "ASSIGNEE",
+    AnonymousAccess = "ANONYMOUS_ACCESS",
+    AnyLoggedinUserApplicationRole = "ANY_LOGGEDIN_USER_APPLICATION_ROLE"
+}
+export declare type JiraGrantTypeValue = JiraDefaultGrantTypeValue | JiraUserGrantTypeValue | JiraProjectRoleGrantTypeValue | JiraGroupGrantTypeValue | JiraIssueFieldGrantTypeValue;
+export declare type JiraGrantTypeValueConnection = {
+    __typename?: 'JiraGrantTypeValueConnection';
+    edges?: Maybe<Array<Maybe<JiraGrantTypeValueEdge>>>;
+    pageInfo: PageInfo;
+    totalCount?: Maybe<Scalars['Int']>;
+};
+export declare type JiraGrantTypeValueEdge = {
+    __typename?: 'JiraGrantTypeValueEdge';
+    node: JiraGrantTypeValue;
+    cursor: Scalars['String'];
+};
+export declare type JiraGroup = {
+    __typename?: 'JiraGroup';
+    id: Scalars['ID'];
+    groupId?: Maybe<Scalars['ID']>;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type JiraGroupConnection = {
+    __typename?: 'JiraGroupConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraGroup>>>;
+};
+export declare type JiraGroupEdge = {
+    __typename?: 'JiraGroupEdge';
+    node?: Maybe<JiraGroup>;
+    cursor: Scalars['String'];
+};
+export declare type JiraGroupGrantTypeValue = Node & {
+    __typename?: 'JiraGroupGrantTypeValue';
+    id: Scalars['ID'];
+    group: JiraGroup;
+};
+export declare type JiraIssue = Node & {
+    __typename?: 'JiraIssue';
+    id: Scalars['ID'];
+    issueId: Scalars['Long'];
+    key: Scalars['String'];
+    fields?: Maybe<JiraIssueFieldConnection>;
+    fieldsById?: Maybe<JiraIssueFieldConnection>;
+};
+export declare type JiraIssueFieldsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueFieldsByIdArgs = {
+    ids: Array<Scalars['ID']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueBranchDevSummary = {
+    __typename?: 'JiraIssueBranchDevSummary';
+    count?: Maybe<Scalars['Int']>;
+    lastUpdated?: Maybe<Scalars['DateTime']>;
+};
+export declare type JiraIssueBranchDevSummaryContainer = {
+    __typename?: 'JiraIssueBranchDevSummaryContainer';
+    overall?: Maybe<JiraIssueBranchDevSummary>;
+    summaryByProvider?: Maybe<Array<JiraIssueDevSummaryByProvider>>;
+};
+export declare type JiraIssueBuildDevSummary = {
+    __typename?: 'JiraIssueBuildDevSummary';
+    count?: Maybe<Scalars['Int']>;
+    lastUpdated?: Maybe<Scalars['DateTime']>;
+    failedBuildCount?: Maybe<Scalars['Int']>;
+    successfulBuildCount?: Maybe<Scalars['Int']>;
+    unknownBuildCount?: Maybe<Scalars['Int']>;
+};
+export declare type JiraIssueBuildDevSummaryContainer = {
+    __typename?: 'JiraIssueBuildDevSummaryContainer';
+    overall?: Maybe<JiraIssueBuildDevSummary>;
+    summaryByProvider?: Maybe<Array<JiraIssueDevSummaryByProvider>>;
+};
+export declare type JiraIssueCommitDevSummary = {
+    __typename?: 'JiraIssueCommitDevSummary';
+    count?: Maybe<Scalars['Int']>;
+    lastUpdated?: Maybe<Scalars['DateTime']>;
+};
+export declare type JiraIssueCommitDevSummaryContainer = {
+    __typename?: 'JiraIssueCommitDevSummaryContainer';
+    overall?: Maybe<JiraIssueCommitDevSummary>;
+    summaryByProvider?: Maybe<Array<JiraIssueDevSummaryByProvider>>;
+};
+export declare type JiraIssueConnection = {
+    __typename?: 'JiraIssueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraIssueEdge>>>;
+};
+export declare type JiraIssueDevSummary = {
+    __typename?: 'JiraIssueDevSummary';
+    branch?: Maybe<JiraIssueBranchDevSummaryContainer>;
+    commit?: Maybe<JiraIssueCommitDevSummaryContainer>;
+    pullrequest?: Maybe<JiraIssuePullRequestDevSummaryContainer>;
+    build?: Maybe<JiraIssueBuildDevSummaryContainer>;
+    review?: Maybe<JiraIssueReviewDevSummaryContainer>;
+};
+export declare type JiraIssueDevSummaryByProvider = {
+    __typename?: 'JiraIssueDevSummaryByProvider';
+    providerId?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    count?: Maybe<Scalars['Int']>;
+};
+export declare type JiraIssueDevSummaryError = {
+    __typename?: 'JiraIssueDevSummaryError';
+    message?: Maybe<Scalars['String']>;
+    instance?: Maybe<JiraIssueDevSummaryErrorProviderInstance>;
+};
+export declare type JiraIssueDevSummaryErrorProviderInstance = {
+    __typename?: 'JiraIssueDevSummaryErrorProviderInstance';
+    name?: Maybe<Scalars['String']>;
+    type?: Maybe<Scalars['String']>;
+    baseUrl?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueDevSummaryResult = {
+    __typename?: 'JiraIssueDevSummaryResult';
+    devSummary?: Maybe<JiraIssueDevSummary>;
+    errors?: Maybe<Array<JiraIssueDevSummaryError>>;
+    configErrors?: Maybe<Array<JiraIssueDevSummaryError>>;
+};
+export declare type JiraIssueEdge = {
+    __typename?: 'JiraIssueEdge';
+    node?: Maybe<JiraIssue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraIssueField = {
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueFieldConfiguration = {
+    fieldConfig?: Maybe<JiraFieldConfig>;
+};
+export declare type JiraIssueFieldConnection = {
+    __typename?: 'JiraIssueFieldConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraIssueFieldEdge>>>;
+};
+export declare type JiraIssueFieldEdge = {
+    __typename?: 'JiraIssueFieldEdge';
+    node?: Maybe<JiraIssueField>;
+    cursor: Scalars['String'];
+};
+export declare type JiraIssueFieldGrantTypeValue = Node & {
+    __typename?: 'JiraIssueFieldGrantTypeValue';
+    id: Scalars['ID'];
+    field: JiraIssueField;
+};
+export declare type JiraIssueLink = {
+    __typename?: 'JiraIssueLink';
+    id?: Maybe<Scalars['ID']>;
+    issueLinkId?: Maybe<Scalars['ID']>;
+    relatedBy?: Maybe<JiraIssueLinkTypeRelation>;
+    issue?: Maybe<JiraIssue>;
+};
+export declare type JiraIssueLinkConnection = {
+    __typename?: 'JiraIssueLinkConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraIssueLinkEdge>>>;
+};
+export declare enum JiraIssueLinkDirection {
+    Inward = "INWARD",
+    Outward = "OUTWARD"
+}
+export declare type JiraIssueLinkEdge = {
+    __typename?: 'JiraIssueLinkEdge';
+    node?: Maybe<JiraIssueLink>;
+    cursor: Scalars['String'];
+};
+export declare type JiraIssueLinkField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraIssueLinkField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    issueLinks?: Maybe<Array<Maybe<JiraIssueLink>>>;
+    issueLinkConnection?: Maybe<JiraIssueLinkConnection>;
+    issueLinkTypeRelations?: Maybe<JiraIssueLinkTypeRelationConnection>;
+    issues?: Maybe<JiraIssueConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraIssueLinkFieldIssueLinkConnectionArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueLinkFieldIssueLinkTypeRelationsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueLinkFieldIssuesArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueLinkTypeRelation = Node & {
+    __typename?: 'JiraIssueLinkTypeRelation';
+    id: Scalars['ID'];
+    relationName?: Maybe<Scalars['String']>;
+    linkTypeId: Scalars['Long'];
+    linkTypeName?: Maybe<Scalars['String']>;
+    direction?: Maybe<JiraIssueLinkDirection>;
+};
+export declare type JiraIssueLinkTypeRelationConnection = {
+    __typename?: 'JiraIssueLinkTypeRelationConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraIssueLinkTypeRelationEdge>>>;
+};
+export declare type JiraIssueLinkTypeRelationEdge = {
+    __typename?: 'JiraIssueLinkTypeRelationEdge';
+    node?: Maybe<JiraIssueLinkTypeRelation>;
+    cursor: Scalars['String'];
+};
+export declare type JiraIssuePullRequestDevSummary = {
+    __typename?: 'JiraIssuePullRequestDevSummary';
+    count?: Maybe<Scalars['Int']>;
+    lastUpdated?: Maybe<Scalars['DateTime']>;
+    state?: Maybe<JiraPullRequestState>;
+    stateCount?: Maybe<Scalars['Int']>;
+    open?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraIssuePullRequestDevSummaryContainer = {
+    __typename?: 'JiraIssuePullRequestDevSummaryContainer';
+    overall?: Maybe<JiraIssuePullRequestDevSummary>;
+    summaryByProvider?: Maybe<Array<JiraIssueDevSummaryByProvider>>;
+};
+export declare type JiraIssueRestrictionField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraIssueRestrictionField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedRoles?: Maybe<Array<Maybe<JiraRole>>>;
+    roles?: Maybe<JiraRoleConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraIssueRestrictionFieldRolesArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraIssueReviewDevSummary = {
+    __typename?: 'JiraIssueReviewDevSummary';
+    count?: Maybe<Scalars['Int']>;
+    lastUpdated?: Maybe<Scalars['DateTime']>;
+    state?: Maybe<JiraReviewState>;
+    stateCount?: Maybe<Scalars['Int']>;
+};
+export declare type JiraIssueReviewDevSummaryContainer = {
+    __typename?: 'JiraIssueReviewDevSummaryContainer';
+    overall?: Maybe<JiraIssueReviewDevSummary>;
+    summaryByProvider?: Maybe<Array<JiraIssueDevSummaryByProvider>>;
+};
+export declare type JiraIssueType = Node & {
+    __typename?: 'JiraIssueType';
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    avatar?: Maybe<JiraAvatar>;
+};
+export declare type JiraIssueTypeConnection = {
+    __typename?: 'JiraIssueTypeConnection';
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraIssueTypeEdge>>>;
+};
+export declare type JiraIssueTypeEdge = {
+    __typename?: 'JiraIssueTypeEdge';
+    node?: Maybe<JiraIssueType>;
+    cursor: Scalars['String'];
+};
+export declare type JiraIssueTypeField = JiraIssueField & JiraIssueFieldConfiguration & {
+    __typename?: 'JiraIssueTypeField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    issueType?: Maybe<JiraIssueType>;
+    issueTypes?: Maybe<JiraIssueTypeConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+};
+export declare type JiraIssueTypeFieldIssueTypesArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare enum JiraJqlAutocompleteType {
+    None = "NONE",
+    Component = "COMPONENT",
+    Group = "GROUP",
+    Issue = "ISSUE",
+    Issuetype = "ISSUETYPE",
+    Priority = "PRIORITY",
+    Project = "PROJECT",
+    Sprint = "SPRINT",
+    Statuscategory = "STATUSCATEGORY",
+    Status = "STATUS",
+    User = "USER",
+    Version = "VERSION"
+}
+export declare type JiraJqlBuilder = {
+    __typename?: 'JiraJqlBuilder';
+    functions: Array<JiraJqlFunction>;
+    lastUsedMode?: Maybe<JiraJqlBuilderMode>;
+    hydrateJqlQuery?: Maybe<JiraJqlHydratedQueryResult>;
+    hydrateJqlQueryForFilter?: Maybe<JiraJqlHydratedQueryResult>;
+    fields?: Maybe<JiraJqlFieldConnectionResult>;
+    recentFields?: Maybe<JiraJqlFieldConnectionResult>;
+    fieldValues?: Maybe<JiraJqlFieldValueConnection>;
+    recentlyUsedUsers?: Maybe<JiraJqlUserFieldValueConnection>;
+    suggestedGroups?: Maybe<JiraJqlGroupFieldValueConnection>;
+    recentlyUsedProjects?: Maybe<JiraJqlProjectFieldValueConnection>;
+    recentlyUsedSprints?: Maybe<JiraJqlSprintFieldValueConnection>;
+    issueTypes?: Maybe<JiraJqlIssueTypes>;
+    cascadingSelectOptions?: Maybe<JiraJqlOptionFieldValueConnection>;
+    versions?: Maybe<JiraJqlVersions>;
+};
+export declare type JiraJqlBuilderHydrateJqlQueryArgs = {
+    query?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderHydrateJqlQueryForFilterArgs = {
+    id: Scalars['ID'];
+};
+export declare type JiraJqlBuilderFieldsArgs = {
+    jqlContext?: Maybe<Scalars['String']>;
+    searchString?: Maybe<Scalars['String']>;
+    forClause?: Maybe<JiraJqlClauseType>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderRecentFieldsArgs = {
+    jqlContext?: Maybe<Scalars['String']>;
+    forClause?: Maybe<JiraJqlClauseType>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderFieldValuesArgs = {
+    jqlContext?: Maybe<Scalars['String']>;
+    jqlTerm: Scalars['String'];
+    searchString?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderRecentlyUsedUsersArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderSuggestedGroupsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderRecentlyUsedProjectsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderRecentlyUsedSprintsArgs = {
+    jqlContext?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderIssueTypesArgs = {
+    jqlContext?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlBuilderCascadingSelectOptionsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    jqlContext?: Maybe<Scalars['String']>;
+    jqlTerm: Scalars['String'];
+    searchString?: Maybe<Scalars['String']>;
+    filter: JiraCascadingSelectOptionsFilter;
+};
+export declare type JiraJqlBuilderVersionsArgs = {
+    jqlContext?: Maybe<Scalars['String']>;
+    jqlTerm: Scalars['String'];
+};
+export declare enum JiraJqlBuilderMode {
+    Jql = "JQL",
+    Basic = "BASIC"
+}
+export declare type JiraJqlCascadingOptionFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlCascadingOptionFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    parentOption?: Maybe<JiraJqlOptionFieldValue>;
+};
+export declare enum JiraJqlClauseType {
+    Any = "ANY",
+    Where = "WHERE",
+    OrderBy = "ORDER_BY"
+}
+export declare type JiraJqlComponentFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlComponentFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+};
+export declare type JiraJqlField = {
+    __typename?: 'JiraJqlField';
+    jqlTerm: Scalars['ID'];
+    displayName?: Maybe<Scalars['String']>;
+    dataTypes?: Maybe<Array<Maybe<Scalars['String']>>>;
+    allowedClauseTypes: Array<JiraJqlClauseType>;
+    operators: Array<JiraJqlOperator>;
+    searchTemplate?: Maybe<JiraJqlSearchTemplate>;
+    autoCompleteTemplate?: Maybe<JiraJqlAutocompleteType>;
+    jqlFieldType?: Maybe<JiraJqlFieldType>;
+    shouldShowInContext?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraJqlFieldConnection = {
+    __typename?: 'JiraJqlFieldConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlFieldEdge>>>;
+};
+export declare type JiraJqlFieldConnectionResult = JiraJqlFieldConnection | QueryError;
+export declare type JiraJqlFieldEdge = {
+    __typename?: 'JiraJqlFieldEdge';
+    node?: Maybe<JiraJqlField>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlFieldType = {
+    __typename?: 'JiraJqlFieldType';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+};
+export declare type JiraJqlFieldValue = {
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+};
+export declare type JiraJqlFieldValueConnection = {
+    __typename?: 'JiraJqlFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlFieldValueEdge>>>;
+};
+export declare type JiraJqlFieldValueEdge = {
+    __typename?: 'JiraJqlFieldValueEdge';
+    node?: Maybe<JiraJqlFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlFunction = {
+    __typename?: 'JiraJqlFunction';
+    displayName?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
+    isList?: Maybe<Scalars['Boolean']>;
+    dataTypes: Array<Scalars['String']>;
+};
+export declare type JiraJqlGroupFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlGroupFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    group: JiraGroup;
+};
+export declare type JiraJqlGroupFieldValueConnection = {
+    __typename?: 'JiraJqlGroupFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlGroupFieldValueEdge>>>;
+};
+export declare type JiraJqlGroupFieldValueEdge = {
+    __typename?: 'JiraJqlGroupFieldValueEdge';
+    node?: Maybe<JiraJqlGroupFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlHydratedQuery = {
+    __typename?: 'JiraJqlHydratedQuery';
+    jql?: Maybe<Scalars['String']>;
+    fields: Array<JiraJqlQueryHydratedFieldResult>;
+};
+export declare type JiraJqlHydratedQueryResult = JiraJqlHydratedQuery | QueryError;
+export declare type JiraJqlIssueFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlIssueFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    issue: JiraIssue;
+};
+export declare type JiraJqlIssueTypeFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlIssueTypeFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    issueTypes: Array<JiraIssueType>;
+};
+export declare type JiraJqlIssueTypeFieldValueConnection = {
+    __typename?: 'JiraJqlIssueTypeFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlIssueTypeFieldValueEdge>>>;
+};
+export declare type JiraJqlIssueTypeFieldValueEdge = {
+    __typename?: 'JiraJqlIssueTypeFieldValueEdge';
+    node?: Maybe<JiraJqlIssueTypeFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlIssueTypes = {
+    __typename?: 'JiraJqlIssueTypes';
+    aboveBaseLevel?: Maybe<JiraJqlIssueTypeFieldValueConnection>;
+    baseLevel?: Maybe<JiraJqlIssueTypeFieldValueConnection>;
+    belowBaseLevel?: Maybe<JiraJqlIssueTypeFieldValueConnection>;
+};
+export declare type JiraJqlIssueTypesAboveBaseLevelArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlIssueTypesBaseLevelArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlIssueTypesBelowBaseLevelArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlLabelFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlLabelFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    label?: Maybe<JiraLabel>;
+};
+export declare enum JiraJqlOperator {
+    Equals = "EQUALS",
+    NotEquals = "NOT_EQUALS",
+    In = "IN",
+    NotIn = "NOT_IN",
+    Is = "IS",
+    IsNot = "IS_NOT",
+    LessThan = "LESS_THAN",
+    LessThanOrEqual = "LESS_THAN_OR_EQUAL",
+    GreaterThan = "GREATER_THAN",
+    GreaterThanOrEqual = "GREATER_THAN_OR_EQUAL",
+    Contains = "CONTAINS",
+    NotContains = "NOT_CONTAINS",
+    WasNotIn = "WAS_NOT_IN",
+    Changed = "CHANGED",
+    WasIn = "WAS_IN",
+    Was = "WAS",
+    WasNot = "WAS_NOT"
+}
+export declare type JiraJqlOptionFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlOptionFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+};
+export declare type JiraJqlOptionFieldValueConnection = {
+    __typename?: 'JiraJqlOptionFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlOptionFieldValueEdge>>>;
+};
+export declare type JiraJqlOptionFieldValueEdge = {
+    __typename?: 'JiraJqlOptionFieldValueEdge';
+    node?: Maybe<JiraJqlOptionFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlPriorityFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlPriorityFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    priority: JiraPriority;
+};
+export declare type JiraJqlProjectFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlProjectFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    project: JiraProject;
+};
+export declare type JiraJqlProjectFieldValueConnection = {
+    __typename?: 'JiraJqlProjectFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlProjectFieldValueEdge>>>;
+};
+export declare type JiraJqlProjectFieldValueEdge = {
+    __typename?: 'JiraJqlProjectFieldValueEdge';
+    node?: Maybe<JiraJqlProjectFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlQueryHydratedError = {
+    __typename?: 'JiraJqlQueryHydratedError';
+    jqlTerm: Scalars['String'];
+    error?: Maybe<QueryError>;
+};
+export declare type JiraJqlQueryHydratedField = {
+    __typename?: 'JiraJqlQueryHydratedField';
+    jqlTerm: Scalars['String'];
+    field: JiraJqlField;
+    values: Array<Maybe<JiraJqlQueryHydratedValueResult>>;
+};
+export declare type JiraJqlQueryHydratedFieldResult = JiraJqlQueryHydratedField | JiraJqlQueryHydratedError;
+export declare type JiraJqlQueryHydratedValue = {
+    __typename?: 'JiraJqlQueryHydratedValue';
+    jqlTerm: Scalars['String'];
+    values: Array<Maybe<JiraJqlFieldValue>>;
+};
+export declare type JiraJqlQueryHydratedValueResult = JiraJqlQueryHydratedValue | JiraJqlQueryHydratedError;
+export declare type JiraJqlResolutionFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlResolutionFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    resolution?: Maybe<JiraResolution>;
+};
+export declare type JiraJqlSearchTemplate = {
+    __typename?: 'JiraJqlSearchTemplate';
+    key?: Maybe<Scalars['String']>;
+};
+export declare type JiraJqlSprintFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlSprintFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    sprint: JiraSprint;
+};
+export declare type JiraJqlSprintFieldValueConnection = {
+    __typename?: 'JiraJqlSprintFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlSprintFieldValueEdge>>>;
+};
+export declare type JiraJqlSprintFieldValueEdge = {
+    __typename?: 'JiraJqlSprintFieldValueEdge';
+    node?: Maybe<JiraJqlSprintFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlStatusCategoryFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlStatusCategoryFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    statusCategory: JiraStatusCategory;
+};
+export declare type JiraJqlStatusFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlStatusFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    statusCategory: JiraStatusCategory;
+};
+export declare type JiraJqlUserFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlUserFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+    user: User;
+};
+export declare type JiraJqlUserFieldValueConnection = {
+    __typename?: 'JiraJqlUserFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlUserFieldValueEdge>>>;
+};
+export declare type JiraJqlUserFieldValueEdge = {
+    __typename?: 'JiraJqlUserFieldValueEdge';
+    node?: Maybe<JiraJqlUserFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlVersionFieldValue = JiraJqlFieldValue & {
+    __typename?: 'JiraJqlVersionFieldValue';
+    jqlTerm: Scalars['String'];
+    displayName: Scalars['String'];
+};
+export declare type JiraJqlVersionFieldValueConnection = {
+    __typename?: 'JiraJqlVersionFieldValueConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraJqlVersionFieldValueEdge>>>;
+};
+export declare type JiraJqlVersionFieldValueEdge = {
+    __typename?: 'JiraJqlVersionFieldValueEdge';
+    node?: Maybe<JiraJqlVersionFieldValue>;
+    cursor: Scalars['String'];
+};
+export declare type JiraJqlVersions = {
+    __typename?: 'JiraJqlVersions';
+    released?: Maybe<JiraJqlVersionFieldValueConnection>;
+    unreleased?: Maybe<JiraJqlVersionFieldValueConnection>;
+    archived?: Maybe<JiraJqlVersionFieldValueConnection>;
+};
+export declare type JiraJqlVersionsReleasedArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    includeArchived?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraJqlVersionsUnreleasedArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    includeArchived?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraJqlVersionsArchivedArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraLabel = {
+    __typename?: 'JiraLabel';
+    labelId?: Maybe<Scalars['ID']>;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type JiraLabelConnection = {
+    __typename?: 'JiraLabelConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraLabelEdge>>>;
+};
+export declare type JiraLabelEdge = {
+    __typename?: 'JiraLabelEdge';
+    node?: Maybe<JiraLabel>;
+    cursor: Scalars['String'];
+};
+export declare type JiraLabelsField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraLabelsField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedLabels?: Maybe<Array<Maybe<JiraLabel>>>;
+    labels?: Maybe<JiraLabelConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraLabelsFieldLabelsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraMediaContext = {
+    __typename?: 'JiraMediaContext';
+    uploadToken?: Maybe<JiraMediaUploadTokenResult>;
+};
+export declare type JiraMediaUploadToken = {
+    __typename?: 'JiraMediaUploadToken';
+    endpointUrl?: Maybe<Scalars['URL']>;
+    clientId?: Maybe<Scalars['String']>;
+    targetCollection?: Maybe<Scalars['String']>;
+    token?: Maybe<Scalars['String']>;
+    tokenDurationInMin?: Maybe<Scalars['Int']>;
+};
+export declare type JiraMediaUploadTokenResult = JiraMediaUploadToken | QueryError;
+export declare type JiraMultipleGroupPickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraMultipleGroupPickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedGroups?: Maybe<Array<Maybe<JiraGroup>>>;
+    groups?: Maybe<JiraGroupConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraMultipleGroupPickerFieldGroupsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraMultipleSelectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraMultipleSelectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedFieldOptions?: Maybe<Array<Maybe<JiraOption>>>;
+    fieldOptions?: Maybe<JiraOptionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraMultipleSelectFieldFieldOptionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraMultipleSelectUserPickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraMultipleSelectUserPickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedUsers?: Maybe<Array<Maybe<User>>>;
+    users?: Maybe<JiraUserConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraMultipleSelectUserPickerFieldUsersArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraMultipleVersionPickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraMultipleVersionPickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedVersions?: Maybe<Array<Maybe<JiraVersion>>>;
+    versions?: Maybe<JiraVersionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraMultipleVersionPickerFieldVersionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraMutation = {
+    __typename?: 'JiraMutation';
+    devOps?: Maybe<JiraDevOpsMutation>;
+    addPermissionSchemeGrants?: Maybe<JiraPermissionSchemeAddGrantPayload>;
+    removePermissionSchemeGrants?: Maybe<JiraPermissionSchemeRemoveGrantPayload>;
+};
+export declare type JiraMutationAddPermissionSchemeGrantsArgs = {
+    input: JiraPermissionSchemeAddGrantInput;
+};
+export declare type JiraMutationRemovePermissionSchemeGrantsArgs = {
+    input: JiraPermissionSchemeRemoveGrantInput;
+};
+export declare type JiraNumberField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraNumberField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    number?: Maybe<Scalars['Float']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraOption = Node & {
+    __typename?: 'JiraOption';
+    id: Scalars['ID'];
+    optionId: Scalars['Long'];
+    value?: Maybe<Scalars['String']>;
+    isDisabled?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraOptionConnection = {
+    __typename?: 'JiraOptionConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraOptionEdge>>>;
+};
+export declare type JiraOptionEdge = {
+    __typename?: 'JiraOptionEdge';
+    node?: Maybe<JiraOption>;
+    cursor: Scalars['String'];
+};
+export declare type JiraOptoutDevOpsIssuePanelNotConnectedPayload = Payload & {
+    __typename?: 'JiraOptoutDevOpsIssuePanelNotConnectedPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type JiraOrderDirection = {
+    id: Scalars['ID'];
+};
+export declare type JiraParentIssueField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraParentIssueField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    parentIssue?: Maybe<JiraIssue>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraPeopleField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraPeopleField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedUsers?: Maybe<Array<Maybe<User>>>;
+    isMulti?: Maybe<Scalars['Boolean']>;
+    users?: Maybe<JiraUserConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraPeopleFieldUsersArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraPermissionGrantHolder = {
+    __typename?: 'JiraPermissionGrantHolder';
+    permission: JiraProjectPermission;
+    grants?: Maybe<Array<JiraPermissionGrants>>;
+};
+export declare type JiraPermissionGrantValue = {
+    __typename?: 'JiraPermissionGrantValue';
+    id: Scalars['ID'];
+    value: JiraGrantTypeValue;
+};
+export declare type JiraPermissionGrantValueConnection = {
+    __typename?: 'JiraPermissionGrantValueConnection';
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraPermissionGrantValueEdge>>>;
+    totalCount?: Maybe<Scalars['Int']>;
+};
+export declare type JiraPermissionGrantValueEdge = {
+    __typename?: 'JiraPermissionGrantValueEdge';
+    node: JiraPermissionGrantValue;
+    cursor: Scalars['String'];
+};
+export declare type JiraPermissionGrants = {
+    __typename?: 'JiraPermissionGrants';
+    grantType: JiraGrantTypeKey;
+    grantValues?: Maybe<Array<JiraPermissionGrantValue>>;
+};
+export declare type JiraPermissionLevel = {
+    __typename?: 'JiraPermissionLevel';
+    group?: Maybe<JiraGroup>;
+    role?: Maybe<JiraRole>;
+};
+export declare type JiraPermissionScheme = Node & {
+    __typename?: 'JiraPermissionScheme';
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+};
+export declare type JiraPermissionSchemeAddGrantInput = {
+    schemeId: Scalars['ID'];
+    grants: Array<JiraPermissionSchemeGrantInput>;
+};
+export declare type JiraPermissionSchemeAddGrantPayload = Payload & {
+    __typename?: 'JiraPermissionSchemeAddGrantPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type JiraPermissionSchemeGrantGroup = {
+    __typename?: 'JiraPermissionSchemeGrantGroup';
+    category: JiraProjectPermissionCategory;
+    grantHolders?: Maybe<Array<Maybe<JiraPermissionGrantHolder>>>;
+};
+export declare type JiraPermissionSchemeGrantInput = {
+    permissionKey: Scalars['String'];
+    grantType: JiraGrantTypeKeyEnum;
+    grantValue: Scalars['ID'];
+};
+export declare type JiraPermissionSchemeRemoveGrantInput = {
+    schemeId: Scalars['ID'];
+    grants: Array<JiraPermissionSchemeGrantInput>;
+};
+export declare type JiraPermissionSchemeRemoveGrantPayload = Payload & {
+    __typename?: 'JiraPermissionSchemeRemoveGrantPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
+export declare type JiraPermissionSchemeView = {
+    __typename?: 'JiraPermissionSchemeView';
+    scheme: JiraPermissionScheme;
+    grantGroups?: Maybe<Array<JiraPermissionSchemeGrantGroup>>;
+};
+export declare type JiraPermissionSchemeViewResult = JiraPermissionSchemeView | QueryError;
+export declare type JiraPriority = Node & {
+    __typename?: 'JiraPriority';
+    id: Scalars['ID'];
+    priorityId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    iconUrl?: Maybe<Scalars['URL']>;
+    color?: Maybe<Scalars['String']>;
+};
+export declare type JiraPriorityConnection = {
+    __typename?: 'JiraPriorityConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraPriorityEdge>>>;
+};
+export declare type JiraPriorityEdge = {
+    __typename?: 'JiraPriorityEdge';
+    node?: Maybe<JiraPriority>;
+    cursor: Scalars['String'];
+};
+export declare type JiraPriorityField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraPriorityField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    priority?: Maybe<JiraPriority>;
+    priorities?: Maybe<JiraPriorityConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraPriorityFieldPrioritiesArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraProject = Node & {
+    __typename?: 'JiraProject';
+    id: Scalars['ID'];
+    key: Scalars['String'];
+    name: Scalars['String'];
+    cloudId: Scalars['ID'];
+    description?: Maybe<Scalars['String']>;
+    leadId?: Maybe<Scalars['ID']>;
+    category?: Maybe<JiraProjectCategory>;
+    avatar?: Maybe<JiraAvatar>;
+    projectUrl?: Maybe<Scalars['String']>;
     repositoryRelationships?: Maybe<JiraProjectAndRepositoryRelationshipConnection>;
     devOpsServiceRelationships?: Maybe<DevOpsServiceAndJiraProjectRelationshipConnection>;
     opsgenieTeamRelationships?: Maybe<JiraProjectAndOpsgenieTeamRelationshipConnection>;
@@ -3800,7 +5861,7 @@ export declare type JiraProjectCategory = Node & {
 };
 export declare type JiraProjectCategoryConnection = {
     __typename?: 'JiraProjectCategoryConnection';
-    pageInfo: JiraProjectsPageInfo;
+    pageInfo: PageInfo;
     edges?: Maybe<Array<Maybe<JiraProjectCategoryEdge>>>;
 };
 export declare type JiraProjectCategoryEdge = {
@@ -3810,7 +5871,7 @@ export declare type JiraProjectCategoryEdge = {
 };
 export declare type JiraProjectConnection = {
     __typename?: 'JiraProjectConnection';
-    pageInfo: JiraProjectsPageInfo;
+    pageInfo: PageInfo;
     edges?: Maybe<Array<Maybe<JiraProjectEdge>>>;
 };
 export declare type JiraProjectEdge = {
@@ -3818,12 +5879,60 @@ export declare type JiraProjectEdge = {
     node?: Maybe<JiraProject>;
     cursor: Scalars['String'];
 };
+export declare type JiraProjectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraProjectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    project?: Maybe<JiraProject>;
+    projects?: Maybe<JiraProjectConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraProjectFieldProjectsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    recent?: Maybe<Scalars['Boolean']>;
+};
 export declare type JiraProjectFilterInput = {
     types?: Maybe<Array<JiraProjectType>>;
     projectCategoryId?: Maybe<Scalars['ID']>;
     keyword?: Maybe<Scalars['String']>;
     sortBy?: Maybe<JiraProjectSortInput>;
 };
+export declare type JiraProjectPermission = {
+    __typename?: 'JiraProjectPermission';
+    key: Scalars['String'];
+    name: Scalars['String'];
+    description: Scalars['String'];
+    type: JiraProjectPermissionCategory;
+};
+export declare type JiraProjectPermissionCategory = {
+    __typename?: 'JiraProjectPermissionCategory';
+    key: JiraProjectPermissionCategoryEnum;
+    name: Scalars['String'];
+};
+export declare enum JiraProjectPermissionCategoryEnum {
+    Projects = "PROJECTS",
+    Issues = "ISSUES",
+    VotersAndWatchers = "VOTERS_AND_WATCHERS",
+    Comments = "COMMENTS",
+    Attachments = "ATTACHMENTS",
+    TimeTracking = "TIME_TRACKING",
+    Other = "OTHER"
+}
+export declare type JiraProjectRoleGrantTypeValue = Node & {
+    __typename?: 'JiraProjectRoleGrantTypeValue';
+    id: Scalars['ID'];
+    role: JiraRole;
+};
 export declare enum JiraProjectSortField {
     Name = "NAME",
     Key = "KEY",
@@ -3839,18 +5948,25 @@ export declare enum JiraProjectType {
     Business = "BUSINESS",
     Software = "SOFTWARE"
 }
-export declare type JiraProjectsPageInfo = {
-    __typename?: 'JiraProjectsPageInfo';
-    hasNextPage: Scalars['Boolean'];
-    hasPreviousPage: Scalars['Boolean'];
-    startCursor?: Maybe<Scalars['String']>;
-    endCursor?: Maybe<Scalars['String']>;
-};
+export declare enum JiraPullRequestState {
+    Open = "OPEN",
+    Declined = "DECLINED",
+    Merged = "MERGED"
+}
 export declare type JiraQuery = {
     __typename?: 'JiraQuery';
     jiraProject?: Maybe<JiraProject>;
     allJiraProjects?: Maybe<JiraProjectConnection>;
     allJiraProjectCategories?: Maybe<JiraProjectCategoryConnection>;
+    devOps?: Maybe<JiraDevOpsQuery>;
+    issueByKey?: Maybe<JiraIssue>;
+    issueById?: Maybe<JiraIssue>;
+    jqlBuilder?: Maybe<JiraJqlBuilder>;
+    allGrantTypeKeys: Array<JiraGrantTypeKey>;
+    grantTypeValues?: Maybe<JiraGrantTypeValueConnection>;
+    viewPermissionScheme?: Maybe<JiraPermissionSchemeViewResult>;
+    getProjectsByPermissionScheme?: Maybe<JiraProjectConnection>;
+    permissionSchemeGrants?: Maybe<JiraPermissionGrantValueConnection>;
 };
 export declare type JiraQueryJiraProjectArgs = {
     id: Scalars['ID'];
@@ -3861,13 +5977,73 @@ export declare type JiraQueryAllJiraProjectsArgs = {
     last?: Maybe<Scalars['Int']>;
     after?: Maybe<Scalars['String']>;
     before?: Maybe<Scalars['String']>;
-    filter: JiraProjectFilterInput;
+    filter: JiraProjectFilterInput;
+};
+export declare type JiraQueryAllJiraProjectCategoriesArgs = {
+    cloudId: Scalars['ID'];
+    first?: Maybe<Scalars['Int']>;
+    last?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraQueryIssueByKeyArgs = {
+    key: Scalars['String'];
+    cloudId: Scalars['ID'];
+};
+export declare type JiraQueryIssueByIdArgs = {
+    id: Scalars['ID'];
+};
+export declare type JiraQueryJqlBuilderArgs = {
+    cloudId: Scalars['ID'];
+};
+export declare type JiraQueryAllGrantTypeKeysArgs = {
+    cloudId: Scalars['ID'];
+};
+export declare type JiraQueryGrantTypeValuesArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    grantTypeKey?: Maybe<JiraGrantTypeKeyEnum>;
+    searchTerm?: Maybe<Scalars['String']>;
+    cloudId: Scalars['ID'];
+};
+export declare type JiraQueryViewPermissionSchemeArgs = {
+    schemeId: Scalars['ID'];
+};
+export declare type JiraQueryGetProjectsByPermissionSchemeArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    schemeId: Scalars['ID'];
+};
+export declare type JiraQueryPermissionSchemeGrantsArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    schemeId: Scalars['ID'];
+    permissionKey?: Maybe<Scalars['String']>;
 };
-export declare type JiraQueryAllJiraProjectCategoriesArgs = {
-    cloudId: Scalars['ID'];
+export declare type JiraRadioSelectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraRadioSelectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedOption?: Maybe<JiraOption>;
+    fieldOptions?: Maybe<JiraOptionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraRadioSelectFieldFieldOptionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
     first?: Maybe<Scalars['Int']>;
-    last?: Maybe<Scalars['Int']>;
     after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
     before?: Maybe<Scalars['String']>;
 };
 export declare type JiraReleases = {
@@ -3928,61 +6104,552 @@ export declare type JiraReleasesEpicConnection = {
     nodes?: Maybe<Array<Maybe<JiraReleasesEpic>>>;
     pageInfo: PageInfo;
 };
-export declare type JiraReleasesEpicEdge = {
-    __typename?: 'JiraReleasesEpicEdge';
-    cursor: Scalars['String'];
-    node?: Maybe<JiraReleasesEpic>;
+export declare type JiraReleasesEpicEdge = {
+    __typename?: 'JiraReleasesEpicEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<JiraReleasesEpic>;
+};
+export declare type JiraReleasesEpicFilter = {
+    projectId: Scalars['ID'];
+    text?: Maybe<Scalars['String']>;
+    releaseStatusFilter?: Maybe<JiraReleasesEpicReleaseStatusFilter>;
+};
+export declare enum JiraReleasesEpicReleaseStatusFilter {
+    Released = "RELEASED",
+    ReleasedAndUnreleased = "RELEASED_AND_UNRELEASED"
+}
+export declare type JiraReleasesIssue = {
+    __typename?: 'JiraReleasesIssue';
+    id: Scalars['ID'];
+    issueKey?: Maybe<Scalars['String']>;
+    issueTypeId?: Maybe<Scalars['ID']>;
+    assignee?: Maybe<User>;
+    summary?: Maybe<Scalars['String']>;
+    lastDeployed?: Maybe<Scalars['DateTime']>;
+    epic?: Maybe<JiraReleasesEpic>;
+};
+export declare type JiraReleasesIssueConnection = {
+    __typename?: 'JiraReleasesIssueConnection';
+    edges?: Maybe<Array<Maybe<JiraReleasesIssueEdge>>>;
+    nodes?: Maybe<Array<Maybe<JiraReleasesIssue>>>;
+    pageInfo: PageInfo;
+};
+export declare type JiraReleasesIssueEdge = {
+    __typename?: 'JiraReleasesIssueEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<JiraReleasesIssue>;
+};
+export declare type JiraReleasesIssueFilter = {
+    projectId: Scalars['ID'];
+    text?: Maybe<Scalars['String']>;
+    epicIds?: Maybe<Array<Maybe<Scalars['ID']>>>;
+    issueTypes?: Maybe<Array<Scalars['ID']>>;
+    assignees?: Maybe<Array<Scalars['ID']>>;
+    fixVersions?: Maybe<Array<Scalars['String']>>;
+    environmentDisplayNames?: Maybe<Array<Scalars['String']>>;
+    environmentCategories?: Maybe<Array<Maybe<DevOpsEnvironmentCategory>>>;
+    releaseStatusFilter?: JiraReleasesIssueReleaseStatusFilter;
+    timeWindow: JiraReleasesTimeWindowInput;
+};
+export declare enum JiraReleasesIssueReleaseStatusFilter {
+    Released = "RELEASED",
+    Unreleased = "UNRELEASED",
+    ReleasedAndUnreleased = "RELEASED_AND_UNRELEASED"
+}
+export declare type JiraReleasesTimeWindowInput = {
+    after: Scalars['DateTime'];
+    before: Scalars['DateTime'];
+};
+export declare type JiraResolution = Node & {
+    __typename?: 'JiraResolution';
+    id: Scalars['ID'];
+    resolutionId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+};
+export declare type JiraResolutionConnection = {
+    __typename?: 'JiraResolutionConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo?: Maybe<PageInfo>;
+    edges?: Maybe<Array<Maybe<JiraResolutionEdge>>>;
+};
+export declare type JiraResolutionEdge = {
+    __typename?: 'JiraResolutionEdge';
+    node?: Maybe<JiraResolution>;
+    cursor: Scalars['String'];
+};
+export declare type JiraResolutionField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraResolutionField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    resolution?: Maybe<JiraResolution>;
+    resolutions?: Maybe<JiraResolutionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraResolutionFieldResolutionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare enum JiraReviewState {
+    Review = "REVIEW",
+    Approval = "APPROVAL",
+    Summarize = "SUMMARIZE",
+    Rejected = "REJECTED",
+    Closed = "CLOSED",
+    Draft = "DRAFT",
+    Dead = "DEAD",
+    Unknown = "UNKNOWN"
+}
+export declare type JiraRichText = {
+    __typename?: 'JiraRichText';
+    plainText?: Maybe<Scalars['String']>;
+    adfValue?: Maybe<JiraAdf>;
+    wikiValue?: Maybe<Scalars['String']>;
+};
+export declare type JiraRichTextField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraRichTextField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    richText?: Maybe<JiraRichText>;
+    renderer?: Maybe<Scalars['String']>;
+    mediaContext?: Maybe<JiraMediaContext>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraRole = {
+    __typename?: 'JiraRole';
+    id: Scalars['ID'];
+    roleId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+};
+export declare type JiraRoleConnection = {
+    __typename?: 'JiraRoleConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraRoleEdge>>>;
+};
+export declare type JiraRoleEdge = {
+    __typename?: 'JiraRoleEdge';
+    node?: Maybe<JiraRole>;
+    cursor: Scalars['String'];
+};
+export declare type JiraSecurityLevel = Node & {
+    __typename?: 'JiraSecurityLevel';
+    id: Scalars['ID'];
+    securityId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+};
+export declare type JiraSecurityLevelConnection = {
+    __typename?: 'JiraSecurityLevelConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraSecurityLevelEdge>>>;
+};
+export declare type JiraSecurityLevelEdge = {
+    __typename?: 'JiraSecurityLevelEdge';
+    node?: Maybe<JiraSecurityLevel>;
+    cursor: Scalars['String'];
+};
+export declare type JiraSecurityLevelField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSecurityLevelField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    securityLevel?: Maybe<JiraSecurityLevel>;
+    securityLevels?: Maybe<JiraSecurityLevelConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSecurityLevelFieldSecurityLevelsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraSingleGroupPickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSingleGroupPickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedGroup?: Maybe<JiraGroup>;
+    groups?: Maybe<JiraGroupConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    searchUrl?: Maybe<Scalars['String']>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSingleGroupPickerFieldGroupsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraSingleLineTextField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSingleLineTextField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    text?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSingleSelectField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSingleSelectField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    fieldOption?: Maybe<JiraOption>;
+    fieldOptions?: Maybe<JiraOptionConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSingleSelectFieldFieldOptionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraSingleSelectUserPickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSingleSelectUserPickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    user?: Maybe<User>;
+    users?: Maybe<JiraUserConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSingleSelectUserPickerFieldUsersArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraSingleVersionPickerField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSingleVersionPickerField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    version?: Maybe<JiraVersion>;
+    versions?: Maybe<JiraVersionConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSingleVersionPickerFieldVersionsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    suggested?: Maybe<Scalars['Boolean']>;
+};
+export declare type JiraSprint = Node & {
+    __typename?: 'JiraSprint';
+    id: Scalars['ID'];
+    sprintId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    state?: Maybe<JiraSprintState>;
+    boardName?: Maybe<Scalars['String']>;
+    startDate?: Maybe<Scalars['DateTime']>;
+    endDate?: Maybe<Scalars['DateTime']>;
+};
+export declare type JiraSprintConnection = {
+    __typename?: 'JiraSprintConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraSprintEdge>>>;
+};
+export declare type JiraSprintEdge = {
+    __typename?: 'JiraSprintEdge';
+    node?: Maybe<JiraSprint>;
+    cursor: Scalars['String'];
+};
+export declare type JiraSprintField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraSprintField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedSprints?: Maybe<Array<Maybe<JiraSprint>>>;
+    sprints?: Maybe<JiraSprintConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSprintFieldSprintsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+    state?: Maybe<JiraSprintState>;
+};
+export declare enum JiraSprintState {
+    Active = "ACTIVE",
+    Future = "FUTURE",
+    Closed = "CLOSED"
+}
+export declare type JiraStatus = Node & {
+    __typename?: 'JiraStatus';
+    id: Scalars['ID'];
+    statusId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    statusCategory?: Maybe<JiraStatusCategory>;
+};
+export declare type JiraStatusCategory = Node & {
+    __typename?: 'JiraStatusCategory';
+    id: Scalars['ID'];
+    statusCategoryId: Scalars['Long'];
+    key?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    colorName?: Maybe<JiraStatusCategoryColor>;
+};
+export declare enum JiraStatusCategoryColor {
+    MediumGray = "MEDIUM_GRAY",
+    Green = "GREEN",
+    Yellow = "YELLOW",
+    Brown = "BROWN",
+    WarmRed = "WARM_RED",
+    BlueGray = "BLUE_GRAY"
+}
+export declare type JiraStatusField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraStatusField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    status: JiraStatus;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraSubtasksField = JiraIssueField & JiraIssueFieldConfiguration & {
+    __typename?: 'JiraSubtasksField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    subtasks?: Maybe<JiraIssueConnection>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+};
+export declare type JiraSubtasksFieldSubtasksArgs = {
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare type JiraTeam = Node & {
+    __typename?: 'JiraTeam';
+    id: Scalars['ID'];
+    teamId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    avatar?: Maybe<JiraAvatar>;
+    members?: Maybe<JiraUserConnection>;
+};
+export declare type JiraTeamConnection = {
+    __typename?: 'JiraTeamConnection';
+    totalCount?: Maybe<Scalars['Int']>;
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraTeamEdge>>>;
+};
+export declare type JiraTeamEdge = {
+    __typename?: 'JiraTeamEdge';
+    node?: Maybe<JiraTeam>;
+    cursor: Scalars['String'];
+};
+export declare type JiraTeamField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraTeamField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    selectedTeam?: Maybe<JiraTeam>;
+    teams?: Maybe<JiraTeamConnection>;
+    searchUrl?: Maybe<Scalars['String']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraTeamFieldTeamsArgs = {
+    searchBy?: Maybe<Scalars['String']>;
+    first?: Maybe<Scalars['Int']>;
+    after?: Maybe<Scalars['String']>;
+    last?: Maybe<Scalars['Int']>;
+    before?: Maybe<Scalars['String']>;
+};
+export declare enum JiraTimeFormat {
+    Pretty = "PRETTY",
+    Days = "DAYS",
+    Hours = "HOURS"
+}
+export declare type JiraTimeTrackingField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraTimeTrackingField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    originalEstimate?: Maybe<JiraEstimate>;
+    remainingEstimate?: Maybe<JiraEstimate>;
+    timeSpent?: Maybe<JiraEstimate>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+    timeTrackingSettings?: Maybe<JiraTimeTrackingSettings>;
+};
+export declare type JiraTimeTrackingSettings = {
+    __typename?: 'JiraTimeTrackingSettings';
+    isJiraConfiguredTimeTrackingEnabled?: Maybe<Scalars['Boolean']>;
+    workingHoursPerDay?: Maybe<Scalars['Float']>;
+    workingDaysPerWeek?: Maybe<Scalars['Float']>;
+    defaultFormat?: Maybe<JiraTimeFormat>;
+    defaultUnit?: Maybe<JiraTimeUnit>;
+};
+export declare enum JiraTimeUnit {
+    Minute = "MINUTE",
+    Hour = "HOUR",
+    Day = "DAY",
+    Week = "WEEK"
+}
+export declare type JiraUrlField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraUrlField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['URL']>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraUserConnection = {
+    __typename?: 'JiraUserConnection';
+    pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraUserEdge>>>;
+    totalCount?: Maybe<Scalars['Int']>;
+};
+export declare type JiraUserEdge = {
+    __typename?: 'JiraUserEdge';
+    node?: Maybe<User>;
+    cursor?: Maybe<Scalars['String']>;
+};
+export declare type JiraUserFieldConfig = {
+    __typename?: 'JiraUserFieldConfig';
+    isPinned?: Maybe<Scalars['Boolean']>;
+    isSelected?: Maybe<Scalars['Boolean']>;
 };
-export declare type JiraReleasesEpicFilter = {
-    projectId: Scalars['ID'];
-    text?: Maybe<Scalars['String']>;
-    releaseStatusFilter?: Maybe<JiraReleasesEpicReleaseStatusFilter>;
+export declare type JiraUserGrantTypeValue = Node & {
+    __typename?: 'JiraUserGrantTypeValue';
+    id: Scalars['ID'];
+    user: User;
 };
-export declare enum JiraReleasesEpicReleaseStatusFilter {
-    Released = "RELEASED",
-    ReleasedAndUnreleased = "RELEASED_AND_UNRELEASED"
-}
-export declare type JiraReleasesIssue = {
-    __typename?: 'JiraReleasesIssue';
+export declare type JiraUserIssueFieldConfiguration = {
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraVersion = Node & {
+    __typename?: 'JiraVersion';
     id: Scalars['ID'];
-    issueKey?: Maybe<Scalars['String']>;
-    issueTypeId?: Maybe<Scalars['ID']>;
-    assignee?: Maybe<User>;
-    summary?: Maybe<Scalars['String']>;
-    lastDeployed?: Maybe<Scalars['DateTime']>;
-    epic?: Maybe<JiraReleasesEpic>;
+    versionId: Scalars['Long'];
+    name?: Maybe<Scalars['String']>;
+    iconUrl?: Maybe<Scalars['URL']>;
+    status?: Maybe<JiraVersionStatus>;
 };
-export declare type JiraReleasesIssueConnection = {
-    __typename?: 'JiraReleasesIssueConnection';
-    edges?: Maybe<Array<Maybe<JiraReleasesIssueEdge>>>;
-    nodes?: Maybe<Array<Maybe<JiraReleasesIssue>>>;
+export declare type JiraVersionConnection = {
+    __typename?: 'JiraVersionConnection';
+    totalCount?: Maybe<Scalars['Int']>;
     pageInfo: PageInfo;
+    edges?: Maybe<Array<Maybe<JiraVersionEdge>>>;
 };
-export declare type JiraReleasesIssueEdge = {
-    __typename?: 'JiraReleasesIssueEdge';
+export declare type JiraVersionEdge = {
+    __typename?: 'JiraVersionEdge';
+    node?: Maybe<JiraVersion>;
     cursor: Scalars['String'];
-    node?: Maybe<JiraReleasesIssue>;
 };
-export declare type JiraReleasesIssueFilter = {
-    projectId: Scalars['ID'];
-    text?: Maybe<Scalars['String']>;
-    epicIds?: Maybe<Array<Maybe<Scalars['ID']>>>;
-    issueTypes?: Maybe<Array<Scalars['ID']>>;
-    assignees?: Maybe<Array<Scalars['ID']>>;
-    fixVersions?: Maybe<Array<Scalars['String']>>;
-    environmentDisplayNames?: Maybe<Array<Scalars['String']>>;
-    environmentCategories?: Maybe<Array<Maybe<DevOpsEnvironmentCategory>>>;
-    releaseStatusFilter?: JiraReleasesIssueReleaseStatusFilter;
-    timeWindow: JiraReleasesTimeWindowInput;
-};
-export declare enum JiraReleasesIssueReleaseStatusFilter {
+export declare enum JiraVersionStatus {
     Released = "RELEASED",
     Unreleased = "UNRELEASED",
-    ReleasedAndUnreleased = "RELEASED_AND_UNRELEASED"
+    Archived = "ARCHIVED"
 }
-export declare type JiraReleasesTimeWindowInput = {
-    after: Scalars['DateTime'];
-    before: Scalars['DateTime'];
+export declare type JiraVote = {
+    __typename?: 'JiraVote';
+    hasVoted?: Maybe<Scalars['Boolean']>;
+    count?: Maybe<Scalars['Long']>;
+};
+export declare type JiraVotesField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraVotesField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    vote?: Maybe<JiraVote>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
+};
+export declare type JiraWatch = {
+    __typename?: 'JiraWatch';
+    isWatching?: Maybe<Scalars['Boolean']>;
+    count?: Maybe<Scalars['Long']>;
+};
+export declare type JiraWatchesField = JiraIssueField & JiraIssueFieldConfiguration & JiraUserIssueFieldConfiguration & {
+    __typename?: 'JiraWatchesField';
+    id: Scalars['ID'];
+    fieldId: Scalars['String'];
+    aliasFieldId?: Maybe<Scalars['ID']>;
+    type: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    watch?: Maybe<JiraWatch>;
+    fieldConfig?: Maybe<JiraFieldConfig>;
+    userFieldConfig?: Maybe<JiraUserFieldConfig>;
 };
 export declare type LabelUsage = {
     __typename?: 'LabelUsage';
@@ -4010,6 +6677,7 @@ export declare type MarketplaceApp = {
     appKey: Scalars['String'];
     name: Scalars['String'];
     partner?: Maybe<MarketplacePartner>;
+    entityStatus: MarketplaceEntityStatus;
     createdAt: Scalars['DateTime'];
     listingStatus: MarketplaceListingStatus;
     productHostingOptions: Array<AtlassianProductHostingType>;
@@ -4163,6 +6831,10 @@ export declare type MarketplaceConnectAppDeployment = MarketplaceAppDeployment &
     isDescriptorFileAvailable: Scalars['Boolean'];
     scopes: Array<ConnectAppScope>;
 };
+export declare enum MarketplaceEntityStatus {
+    Active = "ACTIVE",
+    Archived = "ARCHIVED"
+}
 export declare type MarketplaceImageFile = {
     __typename?: 'MarketplaceImageFile';
     id: Scalars['String'];
@@ -4347,6 +7019,14 @@ export declare type MigrationKeys = {
     jira: Scalars['String'];
     confluence: Scalars['String'];
 };
+export declare type MoveCardOutput = {
+    __typename?: 'MoveCardOutput';
+    issuesWereTransitioned?: Maybe<Scalars['Boolean']>;
+    statusCode?: Maybe<Scalars['Int']>;
+    success?: Maybe<Scalars['Boolean']>;
+    message?: Maybe<Scalars['String']>;
+    clientMutationId?: Maybe<Scalars['ID']>;
+};
 export declare type MoveSprintDownInput = {
     boardId: Scalars['ID'];
     sprintId: Scalars['ID'];
@@ -4371,10 +7051,12 @@ export declare type MoveSprintUpResponse = MutationResponse & {
 };
 export declare type Mutation = {
     __typename?: 'Mutation';
+    customerSupport?: Maybe<SupportRequestCatalogMutationApi>;
     createApp?: Maybe<CreateAppResponse>;
     updateAppDetails?: Maybe<UpdateAppDetailsResponse>;
     deleteApp?: Maybe<DeleteAppResponse>;
     updateAtlassianOAuthClient?: Maybe<UpdateAtlassianOAuthClientResponse>;
+    ecosystem?: Maybe<EcosystemMutation>;
     createColumn?: Maybe<CreateColumnOutput>;
     setColumnName?: Maybe<SetColumnNameOutput>;
     rankColumn?: Maybe<RankColumnOutput>;
@@ -4393,6 +7075,9 @@ export declare type Mutation = {
     createCustomFilter?: Maybe<CustomFilterCreateOutput>;
     updateCustomFilter?: Maybe<CustomFilterCreateOutput>;
     deleteCustomFilter?: Maybe<GenericMutationResponse>;
+    boardCardMove?: Maybe<MoveCardOutput>;
+    assignIssueParent?: Maybe<AssignIssueParentOutput>;
+    unassignIssueParent?: Maybe<UnassignIssueParentOutput>;
     createDevOpsServiceAndOpsgenieTeamRelationship?: Maybe<CreateDevOpsServiceAndOpsgenieTeamRelationshipPayload>;
     updateDevOpsServiceAndOpsgenieTeamRelationship?: Maybe<UpdateDevOpsServiceAndOpsgenieTeamRelationshipPayload>;
     deleteDevOpsServiceAndOpsgenieTeamRelationship?: Maybe<DeleteDevOpsServiceAndOpsgenieTeamRelationshipPayload>;
@@ -4418,6 +7103,8 @@ export declare type Mutation = {
     deleteDevOpsServiceRelationship?: Maybe<DeleteDevOpsServiceRelationshipPayload>;
     updateDevOpsServiceEntityProperties?: Maybe<UpdateDevOpsServiceEntityPropertiesPayload>;
     deleteDevOpsServiceEntityProperties?: Maybe<DeleteDevOpsServiceEntityPropertiesPayload>;
+    jira?: Maybe<JiraMutation>;
+    updateDeveloperLogAccess?: Maybe<UpdateDeveloperLogAccessPayload>;
     appStorage?: Maybe<AppStorageMutation>;
     createPolarisView?: Maybe<CreatePolarisViewPayload>;
     updatePolarisView?: Maybe<UpdatePolarisViewPayload>;
@@ -4456,6 +7143,11 @@ export declare type Mutation = {
     unarchivePolarisInsights?: Maybe<UnarchivePolarisInsightsPayload>;
     createPolarisAnonymousVisitorHash?: Maybe<CreatePolarisAnonymousVisitorHashPayload>;
     deletePolarisAnonymousVisitorHash?: Maybe<DeletePolarisAnonymousVisitorHashPayload>;
+    createPolarisPlay?: Maybe<CreatePolarisPlayPayload>;
+    createPolarisPlayContribution?: Maybe<CreatePolarisPlayContributionPayload>;
+    updatePolarisPlayContribution?: Maybe<UpdatePolarisPlayContributionPayload>;
+    deletePolarisPlayContribution?: Maybe<DeletePolarisPlayContributionPayload>;
+    createPolarisInsightFromPlayContribution?: Maybe<CreatePolarisInsightPayload>;
     createAppTunnels?: Maybe<CreateAppTunnelResponse>;
     deleteAppTunnels?: Maybe<GenericMutationResponse>;
     invokeExtension?: Maybe<InvokeExtensionResponse>;
@@ -4472,7 +7164,7 @@ export declare type Mutation = {
     unwatchMarketplaceApp?: Maybe<UnwatchMarketplaceAppPayload>;
     createAppDeploymentUrl?: Maybe<CreateAppDeploymentUrlResponse>;
     createHostedResourceUploadUrl?: Maybe<CreateHostedResourceUploadUrlPayload>;
-    setExternalAuthCredentials?: Maybe<GenericMutationResponse>;
+    setExternalAuthCredentials?: Maybe<SetExternalAuthCredentialsPayload>;
     setAppEnvironmentVariable?: Maybe<GenericMutationResponse>;
     deleteAppEnvironmentVariable?: Maybe<GenericMutationResponse>;
     createAppDeployment?: Maybe<CreateAppDeploymentResponse>;
@@ -4491,49 +7183,49 @@ export declare type MutationUpdateAtlassianOAuthClientArgs = {
     input: UpdateAtlassianOAuthClientInput;
 };
 export declare type MutationCreateColumnArgs = {
-    input: CreateColumnInput;
+    input?: Maybe<CreateColumnInput>;
 };
 export declare type MutationSetColumnNameArgs = {
-    input: SetColumnNameInput;
+    input?: Maybe<SetColumnNameInput>;
 };
 export declare type MutationRankColumnArgs = {
-    input: RankColumnInput;
+    input?: Maybe<RankColumnInput>;
 };
 export declare type MutationSetColumnLimitArgs = {
-    input: SetColumnLimitInput;
+    input?: Maybe<SetColumnLimitInput>;
 };
 export declare type MutationDeleteColumnArgs = {
-    input: DeleteColumnInput;
+    input?: Maybe<DeleteColumnInput>;
 };
 export declare type MutationStartSprintArgs = {
-    input: StartSprintInput;
+    input?: Maybe<StartSprintInput>;
 };
 export declare type MutationCreateSprintArgs = {
-    input: CreateSprintInput;
+    input?: Maybe<CreateSprintInput>;
 };
 export declare type MutationCompleteSprintArgs = {
-    input: CompleteSprintInput;
+    input?: Maybe<CompleteSprintInput>;
 };
 export declare type MutationDeleteSprintArgs = {
-    input: DeleteSprintInput;
+    input?: Maybe<DeleteSprintInput>;
 };
 export declare type MutationMoveSprintUpArgs = {
-    input: MoveSprintUpInput;
+    input?: Maybe<MoveSprintUpInput>;
 };
 export declare type MutationMoveSprintDownArgs = {
-    input: MoveSprintDownInput;
+    input?: Maybe<MoveSprintDownInput>;
 };
 export declare type MutationEditSprintArgs = {
-    input: EditSprintInput;
+    input?: Maybe<EditSprintInput>;
 };
 export declare type MutationSetUserSwimlaneStrategyArgs = {
-    input: SetSwimlaneStrategyInput;
+    input?: Maybe<SetSwimlaneStrategyInput>;
 };
 export declare type MutationSetSwimlaneStrategyArgs = {
-    input: SetSwimlaneStrategyInput;
+    input?: Maybe<SetSwimlaneStrategyInput>;
 };
 export declare type MutationSetEstimationTypeArgs = {
-    input: SetEstimationTypeInput;
+    input?: Maybe<SetEstimationTypeInput>;
 };
 export declare type MutationCreateCustomFilterArgs = {
     input?: Maybe<CreateCustomFilterInput>;
@@ -4544,6 +7236,15 @@ export declare type MutationUpdateCustomFilterArgs = {
 export declare type MutationDeleteCustomFilterArgs = {
     input?: Maybe<DeleteCustomFilterInput>;
 };
+export declare type MutationBoardCardMoveArgs = {
+    input?: Maybe<BoardCardMoveInput>;
+};
+export declare type MutationAssignIssueParentArgs = {
+    input?: Maybe<AssignIssueParentInput>;
+};
+export declare type MutationUnassignIssueParentArgs = {
+    input?: Maybe<UnassignIssueParentInput>;
+};
 export declare type MutationCreateDevOpsServiceAndOpsgenieTeamRelationshipArgs = {
     input: CreateDevOpsServiceAndOpsgenieTeamRelationshipInput;
 };
@@ -4619,6 +7320,9 @@ export declare type MutationUpdateDevOpsServiceEntityPropertiesArgs = {
 export declare type MutationDeleteDevOpsServiceEntityPropertiesArgs = {
     input: DeleteDevOpsServiceEntityPropertiesInput;
 };
+export declare type MutationUpdateDeveloperLogAccessArgs = {
+    input: UpdateDeveloperLogAccessInput;
+};
 export declare type MutationCreatePolarisViewArgs = {
     input: CreatePolarisViewInput;
 };
@@ -4739,6 +7443,22 @@ export declare type MutationCreatePolarisAnonymousVisitorHashArgs = {
 export declare type MutationDeletePolarisAnonymousVisitorHashArgs = {
     hash: Scalars['String'];
 };
+export declare type MutationCreatePolarisPlayArgs = {
+    input: CreatePolarisPlayInput;
+};
+export declare type MutationCreatePolarisPlayContributionArgs = {
+    input: CreatePolarisPlayContribution;
+};
+export declare type MutationUpdatePolarisPlayContributionArgs = {
+    id: Scalars['ID'];
+    input: UpdatePolarisPlayContribution;
+};
+export declare type MutationDeletePolarisPlayContributionArgs = {
+    id: Scalars['ID'];
+};
+export declare type MutationCreatePolarisInsightFromPlayContributionArgs = {
+    input?: Maybe<CreatePolarisInsightFromPlayContributionInput>;
+};
 export declare type MutationCreateAppTunnelsArgs = {
     input: CreateAppTunnelsInput;
 };
@@ -4835,24 +7555,6 @@ export declare type MyActivitiesViewedArgs = {
     first?: Maybe<Scalars['Int']>;
     after?: Maybe<Scalars['String']>;
 };
-export declare type MyActivity = {
-    __typename?: 'MyActivity';
-    all: ActivityConnection;
-    workedOn: ActivityConnection;
-    viewed: ActivityConnection;
-};
-export declare type MyActivityAllArgs = {
-    filter?: Maybe<ActivityFilter>;
-    first?: Maybe<Scalars['Int']>;
-};
-export declare type MyActivityWorkedOnArgs = {
-    filter?: Maybe<ActivityFilter>;
-    first?: Maybe<Scalars['Int']>;
-};
-export declare type MyActivityViewedArgs = {
-    filter?: Maybe<ActivityFilter>;
-    first?: Maybe<Scalars['Int']>;
-};
 export declare type NadelHydrationArgument = {
     name: Scalars['String'];
     value: Scalars['String'];
@@ -4946,6 +7648,7 @@ export declare type OpsgenieTeam = Node & {
     description?: Maybe<Scalars['String']>;
     createdAt?: Maybe<Scalars['DateTime']>;
     updatedAt?: Maybe<Scalars['DateTime']>;
+    url?: Maybe<Scalars['String']>;
     members?: Maybe<OpsgenieTeamMemberConnection>;
     schedules?: Maybe<Array<Maybe<OpsgenieSchedule>>>;
     alertCounts?: Maybe<Array<Maybe<OpsgenieAlertCountByPriority>>>;
@@ -5034,7 +7737,8 @@ export declare type PolarisComment = {
     account?: Maybe<User>;
 };
 export declare enum PolarisCommentKind {
-    View = "VIEW"
+    View = "VIEW",
+    PlayContribution = "PLAY_CONTRIBUTION"
 }
 export declare type PolarisConnectApp = {
     __typename?: 'PolarisConnectApp';
@@ -5043,6 +7747,7 @@ export declare type PolarisConnectApp = {
     avatarUrl: Scalars['String'];
     oauthClientId: Scalars['String'];
     appId?: Maybe<Scalars['String']>;
+    play?: Maybe<PolarisPlay>;
 };
 export declare type PolarisDecoration = {
     __typename?: 'PolarisDecoration';
@@ -5070,7 +7775,8 @@ export declare enum PolarisFieldType {
     PolarisIdeaOptionField = "PolarisIdeaOptionField",
     PolarisIdeaOptionsField = "PolarisIdeaOptionsField",
     PolarisIdeaLabelsField = "PolarisIdeaLabelsField",
-    PolarisIdeaNumberField = "PolarisIdeaNumberField"
+    PolarisIdeaNumberField = "PolarisIdeaNumberField",
+    PolarisIdeaPlayField = "PolarisIdeaPlayField"
 }
 export declare type PolarisFilterInput = {
     jql?: Maybe<Scalars['String']>;
@@ -5089,6 +7795,7 @@ export declare type PolarisIdea = {
     id: Scalars['ID'];
     archived?: Maybe<Scalars['Boolean']>;
     lastCommentsViewedTimestamp?: Maybe<Scalars['String']>;
+    lastInsightsViewedTimestamp?: Maybe<Scalars['String']>;
 };
 export declare type PolarisIdeaArchivedByField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaArchivedByField';
@@ -5106,6 +7813,7 @@ export declare type PolarisIdeaArchivedByField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaArchivedField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaArchivedField';
@@ -5124,6 +7832,7 @@ export declare type PolarisIdeaArchivedField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaArchivedOnField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaArchivedOnField';
@@ -5141,6 +7850,7 @@ export declare type PolarisIdeaArchivedOnField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaDateField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaDateField';
@@ -5158,6 +7868,7 @@ export declare type PolarisIdeaDateField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaDateTimeField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaDateTimeField';
@@ -5175,6 +7886,7 @@ export declare type PolarisIdeaDateTimeField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaDocumentField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaDocumentField';
@@ -5192,6 +7904,7 @@ export declare type PolarisIdeaDocumentField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaField = {
     id: Scalars['ID'];
@@ -5208,6 +7921,7 @@ export declare type PolarisIdeaField = {
     presentation?: Maybe<PolarisPresentation>;
     formula?: Maybe<Scalars['JSON']>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaFieldOption = {
     __typename?: 'PolarisIdeaFieldOption';
@@ -5231,6 +7945,7 @@ export declare type PolarisIdeaIssueCommentsField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaIssueIdField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaIssueIdField';
@@ -5248,6 +7963,7 @@ export declare type PolarisIdeaIssueIdField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaIssueTypeField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaIssueTypeField';
@@ -5265,6 +7981,7 @@ export declare type PolarisIdeaIssueTypeField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaKeyField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaKeyField';
@@ -5282,6 +7999,7 @@ export declare type PolarisIdeaKeyField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaLabelsField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaLabelsField';
@@ -5299,6 +8017,7 @@ export declare type PolarisIdeaLabelsField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaLinkedIssuesField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaLinkedIssuesField';
@@ -5316,6 +8035,7 @@ export declare type PolarisIdeaLinkedIssuesField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaLinkedIssuesProgressField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaLinkedIssuesProgressField';
@@ -5333,6 +8053,7 @@ export declare type PolarisIdeaLinkedIssuesProgressField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaNumberField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaNumberField';
@@ -5350,6 +8071,7 @@ export declare type PolarisIdeaNumberField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaOptionField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaOptionField';
@@ -5368,6 +8090,7 @@ export declare type PolarisIdeaOptionField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaOptionsField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaOptionsField';
@@ -5386,6 +8109,27 @@ export declare type PolarisIdeaOptionsField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
+};
+export declare type PolarisIdeaPlayField = PolarisIdeaField & {
+    __typename?: 'PolarisIdeaPlayField';
+    id: Scalars['ID'];
+    fieldId?: Maybe<Scalars['Int']>;
+    fieldName?: Maybe<Scalars['String']>;
+    label: Scalars['String'];
+    editable: Scalars['Boolean'];
+    sortable: Scalars['Boolean'];
+    groupable: Scalars['Boolean'];
+    linearizable: Scalars['Boolean'];
+    defaultSortOrder?: Maybe<PolarisSortOrder>;
+    jiraFieldKey?: Maybe<Scalars['String']>;
+    decorations?: Maybe<Array<PolarisDecoration>>;
+    formula?: Maybe<Scalars['JSON']>;
+    presentation?: Maybe<PolarisPresentation>;
+    description?: Maybe<Scalars['String']>;
+    play?: Maybe<PolarisPlay>;
+    aspect?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaSpecialField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaSpecialField';
@@ -5404,6 +8148,7 @@ export declare type PolarisIdeaSpecialField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaStatusField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaStatusField';
@@ -5421,6 +8166,7 @@ export declare type PolarisIdeaStatusField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaStringField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaStringField';
@@ -5438,6 +8184,7 @@ export declare type PolarisIdeaStringField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaType = {
     __typename?: 'PolarisIdeaType';
@@ -5462,6 +8209,7 @@ export declare type PolarisIdeaUserField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaUsersField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaUsersField';
@@ -5479,6 +8227,7 @@ export declare type PolarisIdeaUsersField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeaVotesField = PolarisIdeaField & {
     __typename?: 'PolarisIdeaVotesField';
@@ -5496,6 +8245,7 @@ export declare type PolarisIdeaVotesField = PolarisIdeaField & {
     formula?: Maybe<Scalars['JSON']>;
     presentation?: Maybe<PolarisPresentation>;
     description?: Maybe<Scalars['String']>;
+    builtin?: Maybe<BuiltinPolarisIdeaField>;
 };
 export declare type PolarisIdeas = {
     __typename?: 'PolarisIdeas';
@@ -5512,12 +8262,44 @@ export declare type PolarisInsight = {
     created: Scalars['String'];
     updated: Scalars['String'];
     account?: Maybe<User>;
+    play?: Maybe<PolarisPlay>;
+    contribs?: Maybe<Array<PolarisPlayContribution>>;
 };
 export declare type PolarisIssueLinkType = {
     __typename?: 'PolarisIssueLinkType';
     delivery: Scalars['Int'];
     merge: Scalars['Int'];
+    datapoint: Scalars['Int'];
+};
+export declare type PolarisPlay = {
+    __typename?: 'PolarisPlay';
+    id: Scalars['ID'];
+    label: Scalars['String'];
+    kind: PolarisPlayKind;
+    view?: Maybe<PolarisView>;
+    fields?: Maybe<Array<PolarisIdeaPlayField>>;
+    parameters?: Maybe<Scalars['JSON']>;
+    contributions?: Maybe<Array<PolarisPlayContribution>>;
+    contribution?: Maybe<PolarisPlayContribution>;
+};
+export declare type PolarisPlayContributionArgs = {
+    id: Scalars['ID'];
+};
+export declare type PolarisPlayContribution = {
+    __typename?: 'PolarisPlayContribution';
+    id: Scalars['ID'];
+    play: PolarisPlay;
+    subject: Scalars['ID'];
+    aaid: Scalars['String'];
+    comment?: Maybe<PolarisComment>;
+    amount?: Maybe<Scalars['Int']>;
+    created: Scalars['String'];
+    updated: Scalars['String'];
+    appearsIn?: Maybe<PolarisInsight>;
 };
+export declare enum PolarisPlayKind {
+    PolarisBudgetAllocationPlay = "PolarisBudgetAllocationPlay"
+}
 export declare type PolarisPresentation = {
     __typename?: 'PolarisPresentation';
     type: Scalars['String'];
@@ -5548,6 +8330,13 @@ export declare type PolarisProject = {
     ideas: Array<PolarisIdea>;
     issueLinkType: PolarisIssueLinkType;
     statusCategories?: Maybe<Array<PolarisStatusCategory>>;
+    arjConfiguration: ArjConfiguration;
+    arjHierarchyConfiguration?: Maybe<Array<ArjHierarchyConfigurationLevel>>;
+    plays?: Maybe<Array<PolarisPlay>>;
+    play?: Maybe<PolarisPlay>;
+};
+export declare type PolarisProjectPlayArgs = {
+    id: Scalars['ID'];
 };
 export declare type PolarisProjectTemplate = {
     __typename?: 'PolarisProjectTemplate';
@@ -5715,6 +8504,7 @@ export declare type PolarisView = {
     rank: Scalars['Int'];
     comments?: Maybe<Array<PolarisComment>>;
     containsArchived: Scalars['Boolean'];
+    lastViewed?: Maybe<Array<Maybe<PolarisViewLastViewed>>>;
     lastCommentsViewedTimestamp?: Maybe<Scalars['String']>;
     collabServiceDelegation?: Maybe<PolarisDelegationToken>;
 };
@@ -5759,6 +8549,12 @@ export declare type PolarisViewFilterValueInput = {
     value?: Maybe<Scalars['Float']>;
     operator?: Maybe<PolarisViewFilterOperator>;
 };
+export declare type PolarisViewLastViewed = {
+    __typename?: 'PolarisViewLastViewed';
+    timestamp: Scalars['String'];
+    aaid: Scalars['String'];
+    account?: Maybe<User>;
+};
 export declare type PolarisViewSet = {
     __typename?: 'PolarisViewSet';
     id: Scalars['ID'];
@@ -5795,16 +8591,14 @@ export declare type ProjectAvatars = {
 };
 export declare type Query = {
     __typename?: 'Query';
+    customerSupport?: Maybe<SupportRequestCatalogQueryApi>;
     echo?: Maybe<Scalars['String']>;
     diagnostics?: Maybe<Scalars['JSON']>;
-    customerSupport?: Maybe<SupportRequestCatalogQueryApi>;
-    myActivities: MyActivity;
     activities?: Maybe<Activities>;
     devOpsMetrics?: Maybe<DevOpsMetrics>;
     jiraProjectRelationshipsForRepository?: Maybe<JiraProjectAndRepositoryRelationshipConnection>;
     repositoryRelationshipsForJiraProject?: Maybe<JiraProjectAndRepositoryRelationshipConnection>;
     jiraProjectAndRepositoryRelationship?: Maybe<JiraProjectAndRepositoryRelationship>;
-    jira?: Maybe<JiraQuery>;
     bitbucket?: Maybe<BitbucketQuery>;
     opsgenie?: Maybe<OpsgenieQuery>;
     apps?: Maybe<AppConnection>;
@@ -5835,9 +8629,12 @@ export declare type Query = {
     devOpsServicesById?: Maybe<Array<DevOpsService>>;
     devOpsServiceRelationship?: Maybe<DevOpsServiceRelationship>;
     bitbucketRepositoriesAvailableToLinkWithNewDevOpsService?: Maybe<BitbucketRepositoryIdConnection>;
+    jira?: Maybe<JiraQuery>;
     appLogs?: Maybe<AppLogConnection>;
     appLogLines?: Maybe<AppLogLineConnection>;
     node?: Maybe<Node>;
+    developerLogAccess?: Maybe<Array<Maybe<DeveloperLogAccessResult>>>;
+    installationContextsWithLogAccess?: Maybe<Array<InstallationContextWithLogAccess>>;
     team?: Maybe<TeamQuery>;
     tenantContexts?: Maybe<Array<Maybe<TenantContext>>>;
     testing?: Maybe<Testing>;
@@ -5858,11 +8655,13 @@ export declare type Query = {
     polarisIdeas?: Maybe<PolarisIdeas>;
     polarisAnonymousVisitorHash?: Maybe<PolarisAnonymousVisitorHash>;
     polarisAnonymousVisitorHashByID?: Maybe<PolarisAnonymousVisitorHash>;
+    polarisLinkedDeliveryTickets?: Maybe<Array<Maybe<Scalars['JSON']>>>;
     dvcs?: Maybe<DvcsQuery>;
     appActiveTunnels?: Maybe<AppTunnelDefinitions>;
     webTriggerUrlsByAppContext?: Maybe<Array<WebTriggerUrl>>;
-    jiraReleases?: Maybe<JiraReleases>;
     appInstallationTask?: Maybe<AppInstallationTask>;
+    ecosystem?: Maybe<EcosystemQuery>;
+    jiraReleases?: Maybe<JiraReleases>;
     marketplacePartner?: Maybe<MarketplacePartner>;
     marketplaceApp?: Maybe<MarketplaceApp>;
     marketplaceAppByKey?: Maybe<MarketplaceApp>;
@@ -6018,6 +8817,14 @@ export declare type QueryAppLogLinesArgs = {
 export declare type QueryNodeArgs = {
     id: Scalars['ID'];
 };
+export declare type QueryDeveloperLogAccessArgs = {
+    contextIds: Array<Scalars['ID']>;
+    appId: Scalars['ID'];
+    environmentType: AppEnvironmentType;
+};
+export declare type QueryInstallationContextsWithLogAccessArgs = {
+    appId: Scalars['ID'];
+};
 export declare type QueryTenantContextsArgs = {
     cloudIds?: Maybe<Array<Scalars['ID']>>;
     hostNames?: Maybe<Array<Scalars['String']>>;
@@ -6028,6 +8835,7 @@ export declare type QueryMovieArgs = {
 export declare type QueryAppStoredEntityArgs = {
     contextAri: Scalars['ID'];
     key: Scalars['ID'];
+    encrypted?: Maybe<Scalars['Boolean']>;
 };
 export declare type QueryAppStoredEntitiesArgs = {
     contextAri: Scalars['ID'];
@@ -6076,6 +8884,7 @@ export declare type QueryPolarisIdeasArgs = {
     project: Scalars['ID'];
     fieldKeys?: Maybe<Array<Scalars['String']>>;
     expand?: Maybe<Array<Scalars['String']>>;
+    jql?: Maybe<Scalars['String']>;
 };
 export declare type QueryPolarisAnonymousVisitorHashArgs = {
     hash: Scalars['String'];
@@ -6083,6 +8892,10 @@ export declare type QueryPolarisAnonymousVisitorHashArgs = {
 export declare type QueryPolarisAnonymousVisitorHashByIdArgs = {
     id: Scalars['ID'];
 };
+export declare type QueryPolarisLinkedDeliveryTicketsArgs = {
+    project: Scalars['ID'];
+    issueIds?: Maybe<Array<Scalars['Int']>>;
+};
 export declare type QueryAppActiveTunnelsArgs = {
     appId: Scalars['ID'];
     environmentId: Scalars['ID'];
@@ -6516,6 +9329,7 @@ export declare type SetAppStoredEntityMutationInput = {
     key: Scalars['ID'];
     contextAri: Scalars['ID'];
     value: Scalars['JSON'];
+    encrypted?: Maybe<Scalars['Boolean']>;
 };
 export declare type SetAppStoredEntityPayload = Payload & {
     __typename?: 'SetAppStoredEntityPayload';
@@ -6529,7 +9343,6 @@ export declare type SetColumnLimitInput = {
 };
 export declare type SetColumnLimitOutput = MutationResponse & {
     __typename?: 'SetColumnLimitOutput';
-    updatedColumn?: Maybe<Column>;
     columns?: Maybe<Array<Column>>;
     statusCode: Scalars['Int'];
     success: Scalars['Boolean'];
@@ -6556,6 +9369,11 @@ export declare type SetExternalAuthCredentialsInput = {
     serviceKey: Scalars['String'];
     credentials: ExternalAuthCredentialsInput;
 };
+export declare type SetExternalAuthCredentialsPayload = Payload & {
+    __typename?: 'SetExternalAuthCredentialsPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
 export declare type SetPolarisProjectOnboardedInput = {
     projectId: Scalars['ID'];
     value: Scalars['Boolean'];
@@ -6639,6 +9457,17 @@ export declare type SoftwareCard = {
     dueDate?: Maybe<Scalars['String']>;
     fixVersionsIds: Array<Scalars['ID']>;
 };
+export declare type SoftwareCardChildrenInfo = {
+    __typename?: 'SoftwareCardChildrenInfo';
+    todoStats?: Maybe<SoftwareCardChildrenInfoStats>;
+    inProgressStats?: Maybe<SoftwareCardChildrenInfoStats>;
+    doneStats?: Maybe<SoftwareCardChildrenInfoStats>;
+    lastColumnIssueStats?: Maybe<SoftwareCardChildrenInfoStats>;
+};
+export declare type SoftwareCardChildrenInfoStats = {
+    __typename?: 'SoftwareCardChildrenInfoStats';
+    cardCount?: Maybe<Scalars['Int']>;
+};
 export declare type SoftwareCardTransition = {
     __typename?: 'SoftwareCardTransition';
     id?: Maybe<Scalars['ID']>;
@@ -6648,6 +9477,18 @@ export declare type SoftwareCardTransition = {
     cardType: CardType;
     isGlobal?: Maybe<Scalars['Boolean']>;
     isInitial?: Maybe<Scalars['Boolean']>;
+    hasConditions?: Maybe<Scalars['Boolean']>;
+};
+export declare type SoftwareCardTypeTransition = {
+    __typename?: 'SoftwareCardTypeTransition';
+    transitionId?: Maybe<Scalars['ID']>;
+    name: Scalars['String'];
+    status?: Maybe<CardStatus>;
+    originStatus?: Maybe<CardStatus>;
+    cardType: CardType;
+    isGlobal?: Maybe<Scalars['Boolean']>;
+    isInitial?: Maybe<Scalars['Boolean']>;
+    hasConditions?: Maybe<Scalars['Boolean']>;
 };
 export declare type SoftwareCardsDestination = {
     destination?: Maybe<SoftwareCardsDestinationEnum>;
@@ -6774,17 +9615,10 @@ export declare type StartSprintInput = {
     sprintId: Scalars['ID'];
     name: Scalars['String'];
     goal?: Maybe<Scalars['String']>;
-    startDate: Scalars['DateTime'];
-    endDate: Scalars['DateTime'];
-};
-export declare type Subscription = {
-    __typename?: 'Subscription';
-    onMovieUpdate?: Maybe<TestingMovie>;
-};
-export declare type SubscriptionOnMovieUpdateArgs = {
-    cloudId: Scalars['ID'];
+    startDate: Scalars['String'];
+    endDate: Scalars['String'];
 };
-export declare type SupportRequest = {
+export declare type SupportRequest = SupportRequestCommonRequest & {
     __typename?: 'SupportRequest';
     id: Scalars['ID'];
     summary?: Maybe<Scalars['String']>;
@@ -6808,9 +9642,20 @@ export declare type SupportRequestStatusesArgs = {
     offset?: Maybe<Scalars['Int']>;
     size?: Maybe<Scalars['Int']>;
 };
+export declare type SupportRequestAddCommentInput = {
+    message: Scalars['String'];
+    issueKey: Scalars['String'];
+};
+export declare type SupportRequestCatalogMutationApi = {
+    __typename?: 'SupportRequestCatalogMutationApi';
+    addComment?: Maybe<SupportRequestComment>;
+};
+export declare type SupportRequestCatalogMutationApiAddCommentArgs = {
+    input?: Maybe<SupportRequestAddCommentInput>;
+};
 export declare type SupportRequestCatalogQueryApi = {
     __typename?: 'SupportRequestCatalogQueryApi';
-    me?: Maybe<SupportRequestUser>;
+    me?: Maybe<SupportRequestPage>;
     supportRequest?: Maybe<SupportRequest>;
 };
 export declare type SupportRequestCatalogQueryApiSupportRequestArgs = {
@@ -6830,6 +9675,16 @@ export declare type SupportRequestComments = {
     lastPage: Scalars['Boolean'];
     values: Array<SupportRequestComment>;
 };
+export declare type SupportRequestCommonRequest = {
+    id: Scalars['ID'];
+    summary?: Maybe<Scalars['String']>;
+    description: Scalars['String'];
+    requestTypeName: Scalars['String'];
+    createdDate: SupportRequestDisplayableDateTime;
+    status: SupportRequestStatus;
+    reporter: SupportRequestUser;
+    participants: Array<SupportRequestUser>;
+};
 export declare type SupportRequestContactRelation = {
     __typename?: 'SupportRequestContactRelation';
     openRequest?: Maybe<SupportRequestTicket>;
@@ -6851,6 +9706,24 @@ export declare type SupportRequestFieldValue = {
     __typename?: 'SupportRequestFieldValue';
     value: Scalars['String'];
 };
+export declare type SupportRequestHierarchyRequest = SupportRequestCommonRequest & {
+    __typename?: 'SupportRequestHierarchyRequest';
+    id: Scalars['ID'];
+    summary?: Maybe<Scalars['String']>;
+    description: Scalars['String'];
+    requestTypeName: Scalars['String'];
+    createdDate: SupportRequestDisplayableDateTime;
+    status: SupportRequestStatus;
+    reporter: SupportRequestUser;
+    participants: Array<SupportRequestUser>;
+    parent?: Maybe<SupportRequestHierarchyRequest>;
+    children?: Maybe<Array<SupportRequestHierarchyRequest>>;
+};
+export declare type SupportRequestHierarchyRequests = {
+    __typename?: 'SupportRequestHierarchyRequests';
+    total: Scalars['Int'];
+    page: Array<SupportRequestHierarchyRequest>;
+};
 export declare type SupportRequestNamedContactRelation = {
     __typename?: 'SupportRequestNamedContactRelation';
     orgId?: Maybe<Scalars['String']>;
@@ -6863,6 +9736,29 @@ export declare type SupportRequestNamedContactRelations = {
     cloudEnterpriseRelations?: Maybe<Array<Maybe<SupportRequestNamedContactRelation>>>;
     premierSupportRelations?: Maybe<Array<Maybe<SupportRequestNamedContactRelation>>>;
 };
+export declare type SupportRequestPage = {
+    __typename?: 'SupportRequestPage';
+    profile?: Maybe<SupportRequestUser>;
+    requests?: Maybe<SupportRequests>;
+    migrationRequests?: Maybe<SupportRequestHierarchyRequests>;
+    namedContactRelations?: Maybe<SupportRequestNamedContactRelations>;
+};
+export declare type SupportRequestPageRequestsArgs = {
+    searchTerm?: Maybe<Scalars['String']>;
+    ownership?: Maybe<SupportRequestQueryOwnership>;
+    status?: Maybe<SupportRequestQueryStatusCategory>;
+    offset?: Scalars['Int'];
+    size?: Scalars['Int'];
+    project?: Maybe<Scalars['String']>;
+    requestType?: Maybe<Scalars['String']>;
+    backend?: Maybe<Array<Scalars['String']>>;
+};
+export declare type SupportRequestPageMigrationRequestsArgs = {
+    ownership?: Maybe<SupportRequestQueryOwnership>;
+    status?: Maybe<SupportRequestQueryStatusCategory>;
+    offset?: Scalars['Int'];
+    size?: Scalars['Int'];
+};
 export declare enum SupportRequestQueryOwnership {
     Reporter = "REPORTER",
     Participant = "PARTICIPANT"
@@ -6896,24 +9792,10 @@ export declare type SupportRequestTicket = {
 };
 export declare type SupportRequestUser = {
     __typename?: 'SupportRequestUser';
-    id?: Maybe<Scalars['ID']>;
-    displayName: Scalars['String'];
+    user?: Maybe<User>;
     username?: Maybe<Scalars['String']>;
     email?: Maybe<Scalars['String']>;
-    avatarUrl?: Maybe<Scalars['String']>;
-    impersonating?: Maybe<Scalars['Boolean']>;
-    requests?: Maybe<SupportRequests>;
-    namedContactRelations?: Maybe<SupportRequestNamedContactRelations>;
-};
-export declare type SupportRequestUserRequestsArgs = {
-    searchTerm?: Maybe<Scalars['String']>;
-    ownership?: Maybe<SupportRequestQueryOwnership>;
-    status?: Maybe<SupportRequestQueryStatusCategory>;
-    offset?: Scalars['Int'];
-    size?: Scalars['Int'];
-    project?: Maybe<Scalars['String']>;
-    requestType?: Maybe<Scalars['String']>;
-    backend?: Maybe<Array<Scalars['String']>>;
+    displayName?: Maybe<Scalars['String']>;
 };
 export declare type SupportRequests = {
     __typename?: 'SupportRequests';
@@ -6999,6 +9881,18 @@ export declare type UnarchivePolarisInsightsPayload = Payload & {
     success: Scalars['Boolean'];
     errors?: Maybe<Array<MutationError>>;
 };
+export declare type UnassignIssueParentInput = {
+    boardId: Scalars['ID'];
+    issueIds: Array<Scalars['ID']>;
+};
+export declare type UnassignIssueParentOutput = MutationResponse & {
+    __typename?: 'UnassignIssueParentOutput';
+    boardScope?: Maybe<BoardScope>;
+    statusCode: Scalars['Int'];
+    success: Scalars['Boolean'];
+    message: Scalars['String'];
+    clientMutationId?: Maybe<Scalars['ID']>;
+};
 export declare type UnlinkExternalSourceInput = {
     cloudId: Scalars['ID'];
     ecosystemAppId: Scalars['ID'];
@@ -7025,6 +9919,19 @@ export declare type UpdateAppDetailsResponse = Payload & {
     errors?: Maybe<Array<MutationError>>;
     app?: Maybe<App>;
 };
+export declare type UpdateAppHostServiceScopesInput = {
+    appId: Scalars['ID'];
+    environmentKey: Scalars['String'];
+    serviceId: Scalars['ID'];
+    scopes?: Maybe<Array<Scalars['String']>>;
+};
+export declare type UpdateAppHostServiceScopesResponsePayload = Payload & {
+    __typename?: 'UpdateAppHostServiceScopesResponsePayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    app?: Maybe<App>;
+    appEnvironmentVersion?: Maybe<AppEnvironmentVersion>;
+};
 export declare type UpdateAtlassianOAuthClientInput = {
     clientID: Scalars['ID'];
     callbacks?: Maybe<Array<Scalars['String']>>;
@@ -7119,7 +10026,6 @@ export declare type UpdateCompassScorecardInput = {
     ownerId?: Maybe<Scalars['ID']>;
     componentType?: Maybe<CompassComponentType>;
     importance?: Maybe<CompassScorecardImportance>;
-    criterias?: Maybe<Array<UpdateCompassScorecardCriteriaInput>>;
 };
 export declare type UpdateCompassScorecardPayload = Payload & {
     __typename?: 'UpdateCompassScorecardPayload';
@@ -7218,6 +10124,17 @@ export declare type UpdateDevOpsServiceRelationshipPayload = Payload & {
     errors?: Maybe<Array<MutationError>>;
     serviceRelationship?: Maybe<DevOpsServiceRelationship>;
 };
+export declare type UpdateDeveloperLogAccessInput = {
+    contextIds: Array<Scalars['ID']>;
+    appId: Scalars['ID'];
+    environmentType: AppEnvironmentType;
+    shouldHaveAccess: Scalars['Boolean'];
+};
+export declare type UpdateDeveloperLogAccessPayload = Payload & {
+    __typename?: 'UpdateDeveloperLogAccessPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+};
 export declare type UpdateJiraProjectAndOpsgenieTeamRelationshipInput = {
     id: Scalars['ID'];
     revision: Scalars['ID'];
@@ -7300,6 +10217,7 @@ export declare type UpdatePolarisFieldOptionWeightPayload = Payload & {
 export declare type UpdatePolarisIdeaInput = {
     archived?: Maybe<Scalars['Boolean']>;
     lastCommentsViewedTimestamp?: Maybe<Scalars['String']>;
+    lastInsightsViewedTimestamp?: Maybe<Scalars['String']>;
 };
 export declare type UpdatePolarisIdeaPayload = Payload & {
     __typename?: 'UpdatePolarisIdeaPayload';
@@ -7317,6 +10235,17 @@ export declare type UpdatePolarisInsightPayload = Payload & {
     errors?: Maybe<Array<MutationError>>;
     node?: Maybe<PolarisInsight>;
 };
+export declare type UpdatePolarisPlayContribution = {
+    amount?: Maybe<Scalars['Int']>;
+    comment?: Maybe<Scalars['ID']>;
+    content?: Maybe<Scalars['JSON']>;
+};
+export declare type UpdatePolarisPlayContributionPayload = {
+    __typename?: 'UpdatePolarisPlayContributionPayload';
+    success: Scalars['Boolean'];
+    errors?: Maybe<Array<MutationError>>;
+    node?: Maybe<PolarisPlayContribution>;
+};
 export declare type UpdatePolarisSnippetInput = {
     id?: Maybe<Scalars['ID']>;
     oauthClientId?: Maybe<Scalars['String']>;
@@ -7353,6 +10282,7 @@ export declare type UpdatePolarisViewInput = {
     sort?: Maybe<Array<PolarisSortFieldInput>>;
     filter?: Maybe<Array<PolarisViewFilterInput>>;
     hidden?: Maybe<Array<Scalars['ID']>>;
+    lastViewedTimestamp?: Maybe<Scalars['String']>;
     lastCommentsViewedTimestamp?: Maybe<Scalars['String']>;
 };
 export declare type UpdatePolarisViewPayload = Payload & {
@@ -7410,6 +10340,43 @@ export declare type UserConsentExtensionUser = {
     __typename?: 'UserConsentExtensionUser';
     aaid: Scalars['ID'];
 };
+export declare type UserGrant = {
+    __typename?: 'UserGrant';
+    id: Scalars['ID'];
+    accountId: Scalars['ID'];
+    oauthClientId: Scalars['ID'];
+    appId: Scalars['ID'];
+    appDetails?: Maybe<UserGrantAppDetails>;
+    scopes: Array<Maybe<AppHostServiceScope>>;
+};
+export declare type UserGrantAppDetails = {
+    __typename?: 'UserGrantAppDetails';
+    name: Scalars['String'];
+    description: Scalars['String'];
+    avatarUrl?: Maybe<Scalars['String']>;
+    vendorName?: Maybe<Scalars['String']>;
+    contactLink?: Maybe<Scalars['String']>;
+    privacyPolicyLink?: Maybe<Scalars['String']>;
+    termsOfServiceLink?: Maybe<Scalars['String']>;
+};
+export declare type UserGrantConnection = {
+    __typename?: 'UserGrantConnection';
+    edges?: Maybe<Array<Maybe<UserGrantEdge>>>;
+    nodes?: Maybe<Array<Maybe<UserGrant>>>;
+    pageInfo: UserGrantPageInfo;
+};
+export declare type UserGrantEdge = {
+    __typename?: 'UserGrantEdge';
+    cursor: Scalars['String'];
+    node?: Maybe<UserGrant>;
+};
+export declare type UserGrantPageInfo = {
+    __typename?: 'UserGrantPageInfo';
+    hasNextPage: Scalars['Boolean'];
+    hasPreviousPage: Scalars['Boolean'];
+    startCursor?: Maybe<Scalars['String']>;
+    endCursor?: Maybe<Scalars['String']>;
+};
 export declare type WatchMarketplaceAppPayload = Payload & {
     __typename?: 'WatchMarketplaceAppPayload';
     success: Scalars['Boolean'];