Options
All
  • Public
  • Public/Protected
  • All
Menu

External module "lib/typings/types"

Index

Modules

Enumerations

Type aliases

Type aliases

Application

Application: object

Application-Node

Type declaration

  • Optional __typename?: "Application"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commits?: Maybe<Array<Maybe<Commit>>>

    Application commits Commit

  • Optional data?: Maybe<string>

    data of Application

  • Optional domain?: Maybe<string>

    domain of Application

  • Optional host?: Maybe<string>

    host of Application

  • Optional id?: Maybe<string>

    id of Application

  • Optional state?: Maybe<string>

    state of Application

  • Optional timestamp?: Maybe<string>

    timestamp of Application

ApplicationCommitsArgs

ApplicationCommitsArgs: object

Application-Node

Type declaration

AtomistLog

AtomistLog: object

Atomist log messages

Type declaration

  • Optional __typename?: "AtomistLog"
  • Optional category?: Maybe<string>

    Grouping, namespace etc.

  • Optional correlation_context?: Maybe<AtomistLogCorrelationContext>

    Atomist log correlation context

  • Optional id?: Maybe<string>

    The ID of this AtomistLog

  • Optional level?: Maybe<string>

    Log message level: debug, info, warn, error, fatal

  • Optional message?: Maybe<string>

    Log message

  • Optional team_id?: Maybe<string>

    Team ID for which log message is produced

  • Optional timestamp?: Maybe<number>

    Status timestamp

AtomistLogAutomation

AtomistLogAutomation: object

Automation for which log message is produced

Type declaration

  • Optional __typename?: "AtomistLogAutomation"
  • Optional name?: Maybe<string>

    Automation name

  • Optional version?: Maybe<string>

    Automation description

AtomistLogCorrelationContext

AtomistLogCorrelationContext: object

Atomist log correlation context

Type declaration

  • Optional __typename?: "AtomistLogCorrelationContext"
  • Optional automation?: Maybe<AtomistLogAutomation>

    Automation for which log message is produced

  • Optional correlation_id?: Maybe<string>

    Correlation ID

AtomistLogCorrelationContextAutomationArgs

AtomistLogCorrelationContextAutomationArgs: object

Atomist log correlation context

Type declaration

  • Optional name?: Maybe<string>
  • Optional version?: Maybe<string>

AtomistLogCorrelation_ContextArgs

AtomistLogCorrelation_ContextArgs: object

Atomist log messages

Type declaration

  • Optional correlation_id?: Maybe<string>

Branch

Branch: object

Branch-Node

Type declaration

  • Optional __typename?: "Branch"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    Branch commit Commit

  • Optional id?: Maybe<string>

    id of Branch

  • Optional isRemote?: Maybe<boolean>

    isRemote of Branch

  • Optional name?: Maybe<string>

    name of Branch

  • Optional pullRequests?: Maybe<Array<Maybe<PullRequest>>>

    Branch pullRequests PullRequest

  • Optional remoteRepoHtmlUrl?: Maybe<string>

    remoteRepoHtmlUrl of Branch

  • Optional repo?: Maybe<Repo>

    Branch repo Repo

  • Optional timestamp?: Maybe<string>

    timestamp of Branch

BranchCommitArgs

BranchCommitArgs: object

Branch-Node

Type declaration

BranchPullRequestsArgs

BranchPullRequestsArgs: object

Branch-Node

Type declaration

BranchRepoArgs

BranchRepoArgs: object

Branch-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

Build

Build: object

Build-Node

Type declaration

  • Optional __typename?: "Build"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional buildId?: Maybe<string>

    buildId of Build

  • Optional buildUrl?: Maybe<string>

    buildUrl of Build

  • Optional commit?: Maybe<Commit>

    Build commit Commit

  • Optional compareUrl?: Maybe<string>

    compareUrl of Build

  • Optional data?: Maybe<string>

    data of Build

  • Optional finishedAt?: Maybe<string>

    finishedAt of Build

  • Optional id?: Maybe<string>

    id of Build

  • Optional jobId?: Maybe<string>

    jobId of Build

  • Optional jobName?: Maybe<string>

    jobName of Build

  • Optional name?: Maybe<string>

    name of Build

  • Optional number?: Maybe<number>

    number of Build

  • Optional provider?: Maybe<string>

    provider of Build

  • Optional pullRequest?: Maybe<PullRequest>

    Build pullRequest PullRequest

  • Optional pullRequestNumber?: Maybe<number>

    pullRequestNumber of Build

  • Optional push?: Maybe<Push>

    Build push Push

  • Optional repo?: Maybe<Repo>

    Build repo Repo

  • Optional startedAt?: Maybe<string>

    startedAt of Build

  • Optional status?: Maybe<BuildStatus>

    status of Build

  • Optional tag?: Maybe<Tag>

    Build tag Tag

  • Optional timestamp?: Maybe<string>

    timestamp of Build

  • Optional trigger?: Maybe<BuildTrigger>

    trigger of Build

  • Optional workflow?: Maybe<Workflow>

    Build workflow Workflow

  • Optional workflowId?: Maybe<string>

    workflowId of Build

BuildCommitArgs

BuildCommitArgs: object

Build-Node

Type declaration

BuildForCommitQuery

BuildForCommitQuery: object & object

BuildForCommitQueryVariables

BuildForCommitQueryVariables: object

Type declaration

  • owner: string
  • providerId: string
  • repo: string
  • sha: string

BuildPullRequestArgs

BuildPullRequestArgs: object

Build-Node

Type declaration

BuildPushArgs

BuildPushArgs: object

Build-Node

Type declaration

BuildRepoArgs

BuildRepoArgs: object

Build-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

BuildTagArgs

BuildTagArgs: object

Build-Node

Type declaration

BuildWorkflowArgs

BuildWorkflowArgs: object

Build-Node

Type declaration

Card

Card: object

Type declaration

CardAction

CardAction: object

Type declaration

CardActionGroup

CardActionGroup: object

Type declaration

CardActionParameter

CardActionParameter: object

Type declaration

  • Optional __typename?: "CardActionParameter"
  • Optional name?: Maybe<string>
  • Optional value?: Maybe<string>

CardActionParameterOption

CardActionParameterOption: object

Type declaration

  • Optional __typename?: "CardActionParameterOption"
  • Optional name?: Maybe<string>
  • Optional value?: Maybe<string>

CardActionParameterOptionGroup

CardActionParameterOptionGroup: object

Type declaration

CardBody

CardBody: object

Type declaration

  • Optional __typename?: "CardBody"
  • Optional avatar?: Maybe<string>
  • Optional hint?: Maybe<string>
  • Optional login?: Maybe<string>
  • Optional text?: Maybe<string>
  • Optional ts?: Maybe<number>

CardCollaborator

CardCollaborator: object

Type declaration

  • Optional __typename?: "CardCollaborator"
  • Optional avatar?: Maybe<string>
  • Optional link?: Maybe<string>
  • Optional login?: Maybe<string>

CardCollaboratorsArgs

CardCollaboratorsArgs: object

Type declaration

CardCorrelation

CardCorrelation: object

Type declaration

  • Optional __typename?: "CardCorrelation"
  • Optional body?: Maybe<Array<Maybe<CorrelationBody>>>
  • Optional icon?: Maybe<string>
  • Optional link?: Maybe<string>
  • Optional shortTitle?: Maybe<string>
  • Optional title?: Maybe<string>
  • Optional ts?: Maybe<number>
  • Optional type?: Maybe<string>

CardEvent

CardEvent: object

Type declaration

CardProvenance

CardProvenance: object

Type declaration

  • Optional __typename?: "CardProvenance"
  • Optional name?: Maybe<string>

CardProvenanceArgs

CardProvenanceArgs: object

Type declaration

  • Optional name?: Maybe<string>

CardReaction

CardReaction: object

Type declaration

  • Optional __typename?: "CardReaction"
  • Optional avatar?: Maybe<string>
  • Optional login?: Maybe<string>
  • Optional reaction?: Maybe<string>

CardRepository

CardRepository: object

Type declaration

  • Optional __typename?: "CardRepository"
  • Optional name?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional slug?: Maybe<string>

CardRepositoryArgs

CardRepositoryArgs: object

Type declaration

CardSdmGoal

CardSdmGoal: object

Type declaration

  • Optional __typename?: "CardSdmGoal"
  • Optional actions?: Maybe<Array<Maybe<CardAction>>>
  • Optional description?: Maybe<string>
  • Optional environment?: Maybe<string>
  • Optional link?: Maybe<string>
  • Optional logLink?: Maybe<string>
  • Optional name?: Maybe<string>
  • Optional state?: Maybe<string>
  • Optional ts?: Maybe<number>

CardSdmGoalSet

CardSdmGoalSet: object

Type declaration

CardTitle

CardTitle: object

Type declaration

  • Optional __typename?: "CardTitle"
  • Optional icon?: Maybe<string>
  • Optional text?: Maybe<string>

ChannelLink

ChannelLink: object

ChannelLink-Node

Type declaration

  • Optional __typename?: "ChannelLink"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional channel?: Maybe<ChatChannel>

    ChannelLink channel ChatChannel

  • Optional id?: Maybe<string>

    id of ChannelLink

  • Optional repo?: Maybe<Repo>

    ChannelLink repo Repo

ChannelLinkChannelArgs

ChannelLinkChannelArgs: object

ChannelLink-Node

Type declaration

ChannelLinkRepoArgs

ChannelLinkRepoArgs: object

ChannelLink-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

ChatChannel

ChatChannel: object

ChatChannel-Node

Type declaration

  • Optional __typename?: "ChatChannel"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional archived?: Maybe<boolean>

    archived of ChatChannel

  • Optional botInvitedSelf?: Maybe<boolean>

    botInvitedSelf of ChatChannel

  • Optional channelId?: Maybe<string>

    channelId of ChatChannel

  • Optional createdBy?: Maybe<ChatId>

    ChatChannel createdBy ChatId

  • Optional id?: Maybe<string>

    id of ChatChannel

  • Optional isDefault?: Maybe<boolean>

    isDefault of ChatChannel

  • Optional links?: Maybe<Array<Maybe<ChannelLink>>>

    ChatChannel links ChannelLink

  • Optional members?: Maybe<Array<Maybe<ChatId>>>

    ChatChannel members ChatId

  • Optional name?: Maybe<string>

    name of ChatChannel

  • Optional normalizedName?: Maybe<string>

    normalizedName of ChatChannel

  • Optional provider?: Maybe<string>

    provider of ChatChannel

  • Optional repos?: Maybe<Array<Maybe<Repo>>>

    ChatChannel repos Repo

  • Optional team?: Maybe<ChatTeam>

    ChatChannel team ChatTeam

ChatChannelCreatedByArgs

ChatChannelCreatedByArgs: object

ChatChannel-Node

Type declaration

ChatChannelLinksArgs

ChatChannelLinksArgs: object

ChatChannel-Node

Type declaration

ChatChannelMembersArgs

ChatChannelMembersArgs: object

ChatChannel-Node

Type declaration

ChatChannelReposArgs

ChatChannelReposArgs: object

ChatChannel-Node

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional first?: Maybe<number>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

ChatChannelTeamArgs

ChatChannelTeamArgs: object

ChatChannel-Node

Type declaration

ChatId

ChatId: object

ChatId-Node

Type declaration

  • Optional __typename?: "ChatId"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional channels?: Maybe<Array<Maybe<ChatChannel>>>

    ChatId channels ChatChannel

  • Optional channelsCreated?: Maybe<Array<Maybe<ChatChannel>>>

    ChatId channelsCreated ChatChannel

  • Optional chatTeam?: Maybe<ChatTeam>

    ChatId chatTeam ChatTeam

  • Optional emails?: Maybe<Array<Maybe<Email>>>

    ChatId emails Email

  • Optional id?: Maybe<string>

    id of ChatId

  • Optional isAdmin?: Maybe<string>

    isAdmin of ChatId

  • Optional isAtomistBot?: Maybe<string>

    isAtomistBot of ChatId

  • Optional isBot?: Maybe<string>

    isBot of ChatId

  • Optional isOwner?: Maybe<string>

    isOwner of ChatId

  • Optional isPrimaryOwner?: Maybe<string>

    isPrimaryOwner of ChatId

  • Optional person?: Maybe<Person>

    ChatId person Person

  • Optional preferences?: Maybe<Array<Maybe<UserPreference>>>

    Return a user's preferences

  • Optional provider?: Maybe<string>

    provider of ChatId

  • Optional screenName?: Maybe<string>

    screenName of ChatId

  • Optional timezoneLabel?: Maybe<string>

    timezoneLabel of ChatId

  • Optional userId?: Maybe<string>

    userId of ChatId

ChatIdChannelsArgs

ChatIdChannelsArgs: object

ChatId-Node

Type declaration

ChatIdChannelsCreatedArgs

ChatIdChannelsCreatedArgs: object

ChatId-Node

Type declaration

ChatIdChatTeamArgs

ChatIdChatTeamArgs: object

ChatId-Node

Type declaration

ChatIdEmailsArgs

ChatIdEmailsArgs: object

ChatId-Node

Type declaration

ChatIdPersonArgs

ChatIdPersonArgs: object

ChatId-Node

Type declaration

ChatTeam

ChatTeam: object

ChatTeam-Node

Type declaration

  • Optional __typename?: "ChatTeam"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional channels?: Maybe<Array<Maybe<ChatChannel>>>

    ChatTeam channels ChatChannel

  • Optional domain?: Maybe<string>

    domain of ChatTeam

  • Optional emailDomain?: Maybe<string>

    emailDomain of ChatTeam

  • Optional id?: Maybe<string>

    id of ChatTeam

  • Optional members?: Maybe<Array<Maybe<ChatId>>>

    ChatTeam members ChatId

  • Optional messageCount?: Maybe<number>

    messageCount of ChatTeam

  • Optional name?: Maybe<string>

    name of ChatTeam

  • Optional orgs?: Maybe<Array<Maybe<Org>>>

    ChatTeam orgs Org

  • Optional preferences?: Maybe<Array<Maybe<TeamPreference>>>

    Return a chat team's preferences

  • Optional provider?: Maybe<string>

    provider of ChatTeam

  • Optional providers?: Maybe<Array<Maybe<GitHubProvider>>>

    ChatTeam providers GitHubProvider

  • Optional scmProviders?: Maybe<Array<Maybe<ScmProvider>>>

    ChatTeam scmProviders SCMProvider

  • Optional team?: Maybe<Team>

    ChatTeam team Team

ChatTeamChannelsArgs

ChatTeamChannelsArgs: object

ChatTeam-Node

Type declaration

ChatTeamMembersArgs

ChatTeamMembersArgs: object

ChatTeam-Node

Type declaration

ChatTeamOrgsArgs

ChatTeamOrgsArgs: object

ChatTeam-Node

Type declaration

ChatTeamProvidersArgs

ChatTeamProvidersArgs: object

ChatTeam-Node

Type declaration

ChatTeamScmProvidersArgs

ChatTeamScmProvidersArgs: object

ChatTeam-Node

Type declaration

ChatTeamTeamArgs

ChatTeamTeamArgs: object

ChatTeam-Node

Type declaration

Comment

Comment: object

Comment-Node

Type declaration

  • Optional __typename?: "Comment"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional body?: Maybe<string>

    body of Comment

  • Optional by?: Maybe<ScmId>

    Comment by SCMId

  • Optional commentId?: Maybe<string>

    commentId of Comment

  • Optional commentType?: Maybe<CommentCommentType>

    commentType of Comment

  • Optional createdAt?: Maybe<string>

    createdAt of Comment

  • Optional gitHubId?: Maybe<string>

    gitHubId of Comment

  • Optional htmlUrl?: Maybe<string>

    htmlUrl of Comment

  • Optional id?: Maybe<string>

    id of Comment

  • Optional issue?: Maybe<Issue>

    Comment issue Issue

  • Optional path?: Maybe<string>

    path of Comment

  • Optional position?: Maybe<string>

    position of Comment

  • Optional pullRequest?: Maybe<PullRequest>

    Comment pullRequest PullRequest

  • Optional review?: Maybe<Review>

    Comment review Review

  • Optional timestamp?: Maybe<string>

    timestamp of Comment

  • Optional updatedAt?: Maybe<string>

    updatedAt of Comment

CommentByArgs

CommentByArgs: object

Comment-Node

Type declaration

CommentIssueArgs

CommentIssueArgs: object

Comment-Node

Type declaration

CommentPullRequestArgs

CommentPullRequestArgs: object

Comment-Node

Type declaration

CommentReviewArgs

CommentReviewArgs: object

Comment-Node

Type declaration

Commit

Commit: object

Commit-Node

Type declaration

CommitAppsArgs

CommitAppsArgs: object

Commit-Node

Type declaration

CommitAuthorArgs

CommitAuthorArgs: object

Commit-Node

Type declaration

CommitBuildsArgs

CommitBuildsArgs: object

Commit-Node

Type declaration

CommitCommitterArgs

CommitCommitterArgs: object

Commit-Node

Type declaration

CommitEmailArgs

CommitEmailArgs: object

Commit-Node

Type declaration

CommitFingerprintsArgs

CommitFingerprintsArgs: object

Commit-Node

Type declaration

CommitHerokuAppsArgs

CommitHerokuAppsArgs: object

Commit-Node

Type declaration

CommitImageArgs

CommitImageArgs: object

Commit-Node

Type declaration

CommitImagesArgs

CommitImagesArgs: object

Commit-Node

Type declaration

CommitImpactArgs

CommitImpactArgs: object

Commit-Node

Type declaration

CommitIssueRelationship

CommitIssueRelationship: object

Type declaration

CommitIssueRelationshipCommit

CommitIssueRelationshipCommit: object

Type declaration

  • Optional __typename?: "CommitIssueRelationshipCommit"
  • Optional owner?: Maybe<string>
  • Optional repo?: Maybe<string>
  • Optional sha?: Maybe<string>

CommitIssueRelationshipCommitArgs

CommitIssueRelationshipCommitArgs: object

Type declaration

CommitIssueRelationshipIssue

CommitIssueRelationshipIssue: object

Type declaration

  • Optional __typename?: "CommitIssueRelationshipIssue"
  • Optional name?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional repo?: Maybe<string>

CommitIssueRelationshipIssueArgs

CommitIssueRelationshipIssueArgs: object

Type declaration

CommitPipelinesArgs

CommitPipelinesArgs: object

Commit-Node

Type declaration

CommitPullRequestsArgs

CommitPullRequestsArgs: object

Commit-Node

Type declaration

CommitPushesArgs

CommitPushesArgs: object

Commit-Node

Type declaration

CommitRepoArgs

CommitRepoArgs: object

Commit-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

CommitResolvesArgs

CommitResolvesArgs: object

Commit-Node

Type declaration

CommitStatusesArgs

CommitStatusesArgs: object

Commit-Node

Type declaration

CommitTagsArgs

CommitTagsArgs: object

Commit-Node

Type declaration

CoreRepoFieldsAndChannelsFragment

CoreRepoFieldsAndChannelsFragment: object & object & object

CorrelationBody

CorrelationBody: object

Type declaration

  • Optional __typename?: "CorrelationBody"
  • Optional icon?: Maybe<string>
  • Optional text?: Maybe<string>

DeletedBranch

DeletedBranch: object

DeletedBranch-Node

Type declaration

  • Optional __typename?: "DeletedBranch"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    DeletedBranch commit Commit

  • Optional id?: Maybe<string>

    id of DeletedBranch

  • Optional name?: Maybe<string>

    name of DeletedBranch

  • Optional pullRequests?: Maybe<Array<Maybe<PullRequest>>>

    DeletedBranch pullRequests PullRequest

  • Optional repo?: Maybe<Repo>

    DeletedBranch repo Repo

  • Optional timestamp?: Maybe<string>

    timestamp of DeletedBranch

DeletedBranchCommitArgs

DeletedBranchCommitArgs: object

DeletedBranch-Node

Type declaration

DeletedBranchPullRequestsArgs

DeletedBranchPullRequestsArgs: object

DeletedBranch-Node

Type declaration

DeletedBranchRepoArgs

DeletedBranchRepoArgs: object

DeletedBranch-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

Deployment

Deployment: object

Type declaration

  • Optional __typename?: "Deployment"
  • Optional commit?: Maybe<DeploymentCommit>
  • Optional environment?: Maybe<string>
  • Optional id?: Maybe<string>

    The ID of this Deployment

  • Optional ts?: Maybe<number>

DeploymentCommit

DeploymentCommit: object

Type declaration

  • Optional __typename?: "DeploymentCommit"
  • Optional owner?: Maybe<string>
  • Optional repo?: Maybe<string>
  • Optional sha?: Maybe<string>

DeploymentCommitArgs

DeploymentCommitArgs: object

Type declaration

DeprecatedFingerprint

DeprecatedFingerprint: object

Fingerprint-Node

Type declaration

  • Optional __typename?: "DeprecatedFingerprint"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    Fingerprint commit Commit

  • Optional data?: Maybe<string>

    data of Fingerprint

  • Optional name?: Maybe<string>

    name of Fingerprint

  • Optional sha?: Maybe<string>

    sha of Fingerprint

DeprecatedFingerprintCommitArgs

DeprecatedFingerprintCommitArgs: object

Fingerprint-Node

Type declaration

DeprecatedPushImpact

DeprecatedPushImpact: object

PushImpact-Node

Type declaration

  • Optional __typename?: "DeprecatedPushImpact"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional data?: Maybe<string>

    data of PushImpact

  • Optional id?: Maybe<string>

    id of PushImpact

  • Optional push?: Maybe<Push>

    PushImpact push Push

  • Optional url?: Maybe<string>

    url of PushImpact

DeprecatedPushImpactPushArgs

DeprecatedPushImpactPushArgs: object

PushImpact-Node

Type declaration

DockerImage

DockerImage: object

DockerImage-Node

Type declaration

  • Optional __typename?: "DockerImage"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commits?: Maybe<Array<Maybe<Commit>>>

    DockerImage commits Commit

  • Optional containers?: Maybe<Array<Maybe<K8Container>>>

    DockerImage containers K8Container

  • Optional image?: Maybe<string>

    image of DockerImage

  • Optional imageName?: Maybe<string>

    imageName of DockerImage

  • Optional pods?: Maybe<Array<Maybe<K8Pod>>>

    DockerImage pods K8Pod

  • Optional timestamp?: Maybe<string>

    timestamp of DockerImage

DockerImageCommitsArgs

DockerImageCommitsArgs: object

DockerImage-Node

Type declaration

DockerImageContainersArgs

DockerImageContainersArgs: object

DockerImage-Node

Type declaration

DockerImagePodsArgs

DockerImagePodsArgs: object

DockerImage-Node

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional baseName?: Maybe<string>
  • Optional baseNames?: Maybe<Array<Maybe<string>>>
  • Optional containersCrashLoopBackOff?: Maybe<boolean>
  • Optional containersCrashLoopBackOffs?: Maybe<Array<Maybe<boolean>>>
  • Optional envJSON?: Maybe<string>
  • Optional envJSONs?: Maybe<Array<Maybe<string>>>
  • Optional environment?: Maybe<string>
  • Optional environments?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_K8PodFilter>
  • Optional first?: Maybe<number>
  • Optional host?: Maybe<string>
  • Optional hosts?: Maybe<Array<Maybe<string>>>
  • Optional metadataJSON?: Maybe<string>
  • Optional metadataJSONs?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional namespace?: Maybe<string>
  • Optional namespaces?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>
  • Optional phase?: Maybe<string>
  • Optional phases?: Maybe<Array<Maybe<string>>>
  • Optional resourceVersion?: Maybe<number>
  • Optional resourceVersions?: Maybe<Array<Maybe<number>>>
  • Optional specsJSON?: Maybe<string>
  • Optional specsJSONs?: Maybe<Array<Maybe<string>>>
  • Optional state?: Maybe<string>
  • Optional states?: Maybe<Array<Maybe<string>>>
  • Optional statusJSON?: Maybe<string>
  • Optional statusJSONs?: Maybe<Array<Maybe<string>>>
  • Optional timestamp?: Maybe<string>
  • Optional timestamps?: Maybe<Array<Maybe<string>>>

Email

Email: object

Email-Node

Type declaration

  • Optional __typename?: "Email"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional address?: Maybe<string>

    address of Email

  • Optional chatId?: Maybe<ChatId>

    Email chatId ChatId

  • Optional gitHubId?: Maybe<GitHubId>

    Email gitHubId GitHubId

  • Optional person?: Maybe<Person>

    Email person Person

  • Optional scmId?: Maybe<ScmId>

    Email scmId SCMId

EmailChatIdArgs

EmailChatIdArgs: object

Email-Node

Type declaration

EmailGitHubIdArgs

EmailGitHubIdArgs: object

Email-Node

Type declaration

EmailPersonArgs

EmailPersonArgs: object

Email-Node

Type declaration

EmailScmIdArgs

EmailScmIdArgs: object

Email-Node

Type declaration

Feedback

Feedback: object

Type declaration

  • Optional __typename?: "Feedback"
  • Optional email?: Maybe<string>
  • Optional id?: Maybe<string>

    The ID of this Feedback

  • Optional invocation_id?: Maybe<string>

    compositeId

  • Optional message?: Maybe<string>

GitHubId

GitHubId: object

GitHubId-Node

Type declaration

  • Optional __typename?: "GitHubId"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional emails?: Maybe<Array<Maybe<Email>>>

    GitHubId emails Email

  • Optional login?: Maybe<string>

    login of GitHubId

  • Optional name?: Maybe<string>

    name of GitHubId

  • Optional person?: Maybe<Person>

    GitHubId person Person

  • Optional provider?: Maybe<Array<Maybe<GitHubProvider>>>

    GitHubId provider GitHubProvider

  • Optional scmProvider?: Maybe<ScmProvider>

    GitHubId scmProvider SCMProvider

GitHubIdEmailsArgs

GitHubIdEmailsArgs: object

GitHubId-Node

Type declaration

GitHubIdPersonArgs

GitHubIdPersonArgs: object

GitHubId-Node

Type declaration

GitHubIdProviderArgs

GitHubIdProviderArgs: object

GitHubId-Node

Type declaration

GitHubIdScmProviderArgs

GitHubIdScmProviderArgs: object

GitHubId-Node

Type declaration

GitHubOrgWebhook

GitHubOrgWebhook: object

GitHubOrgWebhook-Node

Type declaration

  • Optional __typename?: "GitHubOrgWebhook"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional id?: Maybe<string>

    id of GitHubOrgWebhook

  • Optional org?: Maybe<Org>

    GitHubOrgWebhook org Org

  • Optional url?: Maybe<string>

    url of GitHubOrgWebhook

  • Optional webhookType?: Maybe<WebhookType>

    webhookType of GitHubOrgWebhook

GitHubOrgWebhookOrgArgs

GitHubOrgWebhookOrgArgs: object

GitHubOrgWebhook-Node

Type declaration

GitHubProvider

GitHubProvider: object

GitHubProvider-Node

Type declaration

  • Optional __typename?: "GitHubProvider"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional apiUrl?: Maybe<string>

    apiUrl of GitHubProvider

  • Optional gitUrl?: Maybe<string>

    gitUrl of GitHubProvider

  • Optional id?: Maybe<string>

    id of GitHubProvider

  • Optional private?: Maybe<boolean>

    private of GitHubProvider

  • Optional providerId?: Maybe<string>

    providerId of GitHubProvider

  • Optional providerType?: Maybe<ProviderType>

    providerType of GitHubProvider

  • Optional team?: Maybe<Team>

    GitHubProvider team Team

  • Optional url?: Maybe<string>

    url of GitHubProvider

GitHubProviderTeamArgs

GitHubProviderTeamArgs: object

GitHubProvider-Node

Type declaration

HerokuApp

HerokuApp: object

HerokuApp-Node

Type declaration

  • Optional __typename?: "HerokuApp"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional app?: Maybe<string>

    app of HerokuApp

  • Optional appId?: Maybe<string>

    appId of HerokuApp

  • Optional commits?: Maybe<Array<Maybe<Commit>>>

    HerokuApp commits Commit

  • Optional release?: Maybe<string>

    release of HerokuApp

  • Optional timestamp?: Maybe<string>

    timestamp of HerokuApp

  • Optional url?: Maybe<string>

    url of HerokuApp

  • Optional user?: Maybe<string>

    user of HerokuApp

HerokuAppCommitsArgs

HerokuAppCommitsArgs: object

HerokuApp-Node

Type declaration

ImageLinked

ImageLinked: object

ImageLinked-Node

Type declaration

  • Optional __typename?: "ImageLinked"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    ImageLinked commit Commit

  • Optional image?: Maybe<DockerImage>

    ImageLinked image DockerImage

  • Optional timestamp?: Maybe<string>

    timestamp of ImageLinked

ImageLinkedCommitArgs

ImageLinkedCommitArgs: object

ImageLinked-Node

Type declaration

ImageLinkedImageArgs

ImageLinkedImageArgs: object

ImageLinked-Node

Type declaration

Issue

Issue: object

Issue-Node

Type declaration

  • Optional __typename?: "Issue"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional action?: Maybe<string>

    action of Issue

  • Optional assignees?: Maybe<Array<Maybe<ScmId>>>

    Issue assignees SCMId

  • Optional body?: Maybe<string>

    body of Issue

  • Optional closedAt?: Maybe<string>

    closedAt of Issue

  • Optional closedBy?: Maybe<ScmId>

    Issue closedBy SCMId

  • Optional comments?: Maybe<Array<Maybe<Comment>>>

    Issue comments Comment

  • Optional createdAt?: Maybe<string>

    createdAt of Issue

  • Optional id?: Maybe<string>

    id of Issue

  • Optional labels?: Maybe<Array<Maybe<Label>>>

    Issue labels Label

  • Optional lastAssignedBy?: Maybe<ScmId>

    Issue lastAssignedBy SCMId

  • Optional name?: Maybe<string>

    name of Issue

  • Optional number?: Maybe<number>

    number of Issue

  • Optional openedBy?: Maybe<ScmId>

    Issue openedBy SCMId

  • repo: Repo

    Issue repo Repo

  • Optional resolvingCommits?: Maybe<Array<Maybe<Commit>>>

    Issue resolvingCommits Commit

  • Optional state?: Maybe<IssueState>

    state of Issue

  • Optional timestamp?: Maybe<string>

    timestamp of Issue

  • Optional title?: Maybe<string>

    title of Issue

  • Optional updatedAt?: Maybe<string>

    updatedAt of Issue

IssueAssigneesArgs

IssueAssigneesArgs: object

Issue-Node

Type declaration

IssueClosedByArgs

IssueClosedByArgs: object

Issue-Node

Type declaration

IssueCommentsArgs

IssueCommentsArgs: object

Issue-Node

Type declaration

IssueLabelsArgs

IssueLabelsArgs: object

Issue-Node

Type declaration

IssueLastAssignedByArgs

IssueLastAssignedByArgs: object

Issue-Node

Type declaration

IssueOpenedByArgs

IssueOpenedByArgs: object

Issue-Node

Type declaration

IssueRelationship

IssueRelationship: object

Type declaration

IssueRelationshipIssue

IssueRelationshipIssue: object

Type declaration

  • Optional __typename?: "IssueRelationshipIssue"
  • Optional issue?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional repo?: Maybe<string>

IssueRelationshipSourceArgs

IssueRelationshipSourceArgs: object

Type declaration

IssueRelationshipTargetArgs

IssueRelationshipTargetArgs: object

Type declaration

IssueRepoArgs

IssueRepoArgs: object

Issue-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

IssueResolvingCommitsArgs

IssueResolvingCommitsArgs: object

Issue-Node

Type declaration

Job

Job: object

Job-Node

Type declaration

  • Optional __typename?: "Job"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional finishedAt?: Maybe<string>

    finishedAt of Job

  • Optional jobId?: Maybe<string>

    jobId of Job

  • Optional manual?: Maybe<boolean>

    manual of Job

  • Optional name?: Maybe<string>

    name of Job

  • Optional runner?: Maybe<string>

    runner of Job

  • Optional stage?: Maybe<Stage>

    Job stage Stage

  • Optional startedAt?: Maybe<string>

    startedAt of Job

  • Optional status?: Maybe<JobStatus>

    status of Job

  • Optional when?: Maybe<string>

    when of Job

JobStageArgs

JobStageArgs: object

Job-Node

Type declaration

K8Container

K8Container: object

K8Container-Node

Type declaration

  • Optional __typename?: "K8Container"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional containerID?: Maybe<string>

    containerID of K8Container

  • Optional containerJSON?: Maybe<string>

    containerJSON of K8Container

  • Optional environment?: Maybe<string>

    environment of K8Container

  • Optional image?: Maybe<DockerImage>

    K8Container image DockerImage

  • Optional imageName?: Maybe<string>

    imageName of K8Container

  • Optional name?: Maybe<string>

    name of K8Container

  • Optional pod?: Maybe<K8Pod>

    K8Container pod K8Pod

  • Optional ready?: Maybe<boolean>

    ready of K8Container

  • Optional resourceVersion?: Maybe<number>

    resourceVersion of K8Container

  • Optional restartCount?: Maybe<number>

    restartCount of K8Container

  • Optional state?: Maybe<string>

    state of K8Container

  • Optional stateReason?: Maybe<string>

    stateReason of K8Container

  • Optional statusJSON?: Maybe<string>

    statusJSON of K8Container

  • Optional timestamp?: Maybe<string>

    timestamp of K8Container

K8ContainerImageArgs

K8ContainerImageArgs: object

K8Container-Node

Type declaration

K8ContainerPodArgs

K8ContainerPodArgs: object

K8Container-Node

Type declaration

  • Optional baseName?: Maybe<string>
  • Optional baseNames?: Maybe<Array<Maybe<string>>>
  • Optional containersCrashLoopBackOff?: Maybe<boolean>
  • Optional containersCrashLoopBackOffs?: Maybe<Array<Maybe<boolean>>>
  • Optional envJSON?: Maybe<string>
  • Optional envJSONs?: Maybe<Array<Maybe<string>>>
  • Optional environment?: Maybe<string>
  • Optional environments?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_K8PodFilter>
  • Optional host?: Maybe<string>
  • Optional hosts?: Maybe<Array<Maybe<string>>>
  • Optional metadataJSON?: Maybe<string>
  • Optional metadataJSONs?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional namespace?: Maybe<string>
  • Optional namespaces?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>
  • Optional phase?: Maybe<string>
  • Optional phases?: Maybe<Array<Maybe<string>>>
  • Optional resourceVersion?: Maybe<number>
  • Optional resourceVersions?: Maybe<Array<Maybe<number>>>
  • Optional specsJSON?: Maybe<string>
  • Optional specsJSONs?: Maybe<Array<Maybe<string>>>
  • Optional state?: Maybe<string>
  • Optional states?: Maybe<Array<Maybe<string>>>
  • Optional statusJSON?: Maybe<string>
  • Optional statusJSONs?: Maybe<Array<Maybe<string>>>
  • Optional timestamp?: Maybe<string>
  • Optional timestamps?: Maybe<Array<Maybe<string>>>

K8Pod

K8Pod: object

K8Pod-Node

Type declaration

  • Optional __typename?: "K8Pod"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional baseName?: Maybe<string>

    baseName of K8Pod

  • Optional containers?: Maybe<Array<Maybe<K8Container>>>

    K8Pod containers K8Container

  • Optional containersCrashLoopBackOff?: Maybe<boolean>

    containersCrashLoopBackOff of K8Pod

  • Optional envJSON?: Maybe<string>

    envJSON of K8Pod

  • Optional environment?: Maybe<string>

    environment of K8Pod

  • Optional host?: Maybe<string>

    host of K8Pod

  • Optional images?: Maybe<Array<Maybe<DockerImage>>>

    K8Pod images DockerImage

  • Optional metadataJSON?: Maybe<string>

    metadataJSON of K8Pod

  • Optional name?: Maybe<string>

    name of K8Pod

  • Optional namespace?: Maybe<string>

    namespace of K8Pod

  • Optional phase?: Maybe<string>

    phase of K8Pod

  • Optional resourceVersion?: Maybe<number>

    resourceVersion of K8Pod

  • Optional specsJSON?: Maybe<string>

    specsJSON of K8Pod

  • Optional state?: Maybe<string>

    state of K8Pod

  • Optional statusJSON?: Maybe<string>

    statusJSON of K8Pod

  • Optional timestamp?: Maybe<string>

    timestamp of K8Pod

K8PodContainersArgs

K8PodContainersArgs: object

K8Pod-Node

Type declaration

K8PodImagesArgs

K8PodImagesArgs: object

K8Pod-Node

Type declaration

Label

Label: object

Label-Node

Type declaration

  • Optional __typename?: "Label"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional color?: Maybe<string>

    color of Label

  • Optional default?: Maybe<string>

    default of Label

  • Optional id?: Maybe<string>

    id of Label

  • Optional name?: Maybe<string>

    name of Label

  • Optional repo?: Maybe<Repo>

    Label repo Repo

LabelRepoArgs

LabelRepoArgs: object

Label-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

ManifestoSignature

ManifestoSignature: object

Type declaration

  • Optional __typename?: "ManifestoSignature"
  • Optional email?: Maybe<string>
  • Optional id?: Maybe<string>

    The ID of this ManifestoSignature

  • Optional user?: Maybe<string>
  • Optional userId?: Maybe<string>

    compositeId

  • Optional userName?: Maybe<string>

Maybe

Maybe<T>: T | null

Type parameters

  • T

MutationType

MutationType: object

Type declaration

  • Optional __typename?: "MutationType"
  • Optional addBotToSlackChannel?: Maybe<SlackChannel>

    Ask the bot to join a chat channel

  • Optional createSlackChannel?: Maybe<SlackChannel>

    Create a slack channel in the current team

  • Optional inviteUserToSlackChannel?: Maybe<SlackChannel>

    Ask the bot to invite a user to join a chat channel

  • Optional kickUserFromSlackChannel?: Maybe<SlackChannel>

    Ask the bot to kick a user from a chat channel

  • Optional linkSlackChannelToRepo?: Maybe<SlackChannel>

    Link a channel to a repo

  • Optional setChatTeamPreference?: Maybe<Array<Maybe<TeamPreference>>>

    Set the value of a chat team preference. Returns what was set

  • Optional setChatUserPreference?: Maybe<Array<Maybe<UserPreference>>>

    Set the value of a user preference.

  • Optional setOwnerLogin?: Maybe<OwnerLogin>

    set a GitHub login to be used for resources owned by an Org

  • Optional setPersonPreference?: Maybe<Array<Maybe<PersonPreference>>>

    Set the value of a person preference. Returns what was set

  • Optional setRepoLogin?: Maybe<RepoLogin>

    set a GitHub login to be used for this Repository

  • Optional setTeamProperties?: Maybe<Team>

    Set a team's properties

  • Optional unlinkSlackChannelFromRepo?: Maybe<SlackChannel>

    Unlink a channel from a repo

MutationTypeAddBotToSlackChannelArgs

MutationTypeAddBotToSlackChannelArgs: object

Type declaration

  • Optional channelId?: Maybe<string>
  • Optional chatTeamId?: Maybe<string>

MutationTypeCreateSlackChannelArgs

MutationTypeCreateSlackChannelArgs: object

Type declaration

  • Optional chatTeamId?: Maybe<string>
  • Optional name?: Maybe<string>

MutationTypeInviteUserToSlackChannelArgs

MutationTypeInviteUserToSlackChannelArgs: object

Type declaration

  • Optional channelId?: Maybe<string>
  • Optional chatTeamId?: Maybe<string>
  • Optional userId?: Maybe<string>

MutationTypeKickUserFromSlackChannelArgs

MutationTypeKickUserFromSlackChannelArgs: object

Type declaration

  • Optional channelId?: Maybe<string>
  • Optional chatTeamId?: Maybe<string>
  • Optional userId?: Maybe<string>

MutationTypeLinkSlackChannelToRepoArgs

MutationTypeLinkSlackChannelToRepoArgs: object

Type declaration

  • Optional channelId?: Maybe<string>
  • Optional channelName?: Maybe<string>
  • Optional chatTeamId?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>
  • Optional repo?: Maybe<string>

MutationTypeSetChatTeamPreferenceArgs

MutationTypeSetChatTeamPreferenceArgs: object

Type declaration

  • Optional chatTeamId?: Maybe<string>
  • Optional name?: Maybe<string>
  • Optional value?: Maybe<string>

MutationTypeSetChatUserPreferenceArgs

MutationTypeSetChatUserPreferenceArgs: object

Type declaration

  • Optional chatTeamId?: Maybe<string>
  • Optional chatUserId?: Maybe<string>
  • Optional name?: Maybe<string>
  • Optional value?: Maybe<string>

MutationTypeSetOwnerLoginArgs

MutationTypeSetOwnerLoginArgs: object

Type declaration

  • Optional login?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>

MutationTypeSetPersonPreferenceArgs

MutationTypeSetPersonPreferenceArgs: object

Type declaration

  • Optional name?: Maybe<string>
  • Optional personId?: Maybe<string>
  • Optional value?: Maybe<string>

MutationTypeSetRepoLoginArgs

MutationTypeSetRepoLoginArgs: object

Type declaration

  • Optional login?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>
  • Optional repo?: Maybe<string>

MutationTypeSetTeamPropertiesArgs

MutationTypeSetTeamPropertiesArgs: object

Type declaration

  • Optional description?: Maybe<string>
  • Optional iconUrl?: Maybe<string>
  • Optional name?: Maybe<string>

MutationTypeUnlinkSlackChannelFromRepoArgs

MutationTypeUnlinkSlackChannelFromRepoArgs: object

Type declaration

  • Optional channelId?: Maybe<string>
  • Optional chatTeamId?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>
  • Optional repo?: Maybe<string>

Notification

Notification: object

Type declaration

NotificationAction

NotificationAction: object

Type declaration

NotificationActionGroup

NotificationActionGroup: object

Type declaration

  • Optional __typename?: "NotificationActionGroup"
  • Optional actions?: Maybe<Array<Maybe<CardAction>>>
  • Optional text?: Maybe<string>

NotificationActionParameter

NotificationActionParameter: object

Type declaration

  • Optional __typename?: "NotificationActionParameter"
  • Optional name?: Maybe<string>
  • Optional value?: Maybe<string>

NotificationActionParameterOption

NotificationActionParameterOption: object

Type declaration

  • Optional __typename?: "NotificationActionParameterOption"
  • Optional name?: Maybe<string>
  • Optional value?: Maybe<string>

NotificationActionParameterOptionGroup

NotificationActionParameterOptionGroup: object

Type declaration

NotificationRecipient

NotificationRecipient: object

Type declaration

  • Optional __typename?: "NotificationRecipient"
  • address: string

NotificationRecipientArgs

NotificationRecipientArgs: object

Type declaration

OnBuildCompleteSubscription

OnBuildCompleteSubscription: object & object

OnBuildCompleteSubscriptionVariables

OnBuildCompleteSubscriptionVariables: object

Type declaration

OnImageLinkedSubscription

OnImageLinkedSubscription: object & object

OnImageLinkedSubscriptionVariables

OnImageLinkedSubscriptionVariables: object

Type declaration

Org

Org: object

Org-Node

Type declaration

OrgChatTeamArgs

OrgChatTeamArgs: object

Org-Node

Type declaration

OrgProviderArgs

OrgProviderArgs: object

Org-Node

Type declaration

OrgRepoArgs

OrgRepoArgs: object

Org-Node

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional first?: Maybe<number>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

OrgReposArgs

OrgReposArgs: object

Org-Node

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional first?: Maybe<number>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

OrgScmProviderArgs

OrgScmProviderArgs: object

Org-Node

Type declaration

OrgTeamArgs

OrgTeamArgs: object

Org-Node

Type declaration

OrgWebhookArgs

OrgWebhookArgs: object

Org-Node

Type declaration

OrgWebhooksArgs

OrgWebhooksArgs: object

Org-Node

Type declaration

OwnerLogin

OwnerLogin: object

a GitHub Owner (like an Org) can set a login to be used for background tasks

Type declaration

  • Optional __typename?: "OwnerLogin"
  • Optional login?: Maybe<string>

    The login that should be used

  • Optional owner?: Maybe<string>

    The owner name for the Organization/Team

  • Optional providerId?: Maybe<string>

    The id of the git provider for this Owner

ParentImpact

ParentImpact: object

ParentImpact-Node

Type declaration

  • Optional __typename?: "ParentImpact"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    ParentImpact commit Commit

  • Optional commits?: Maybe<Array<Maybe<Commit>>>

    ParentImpact commits Commit

  • Optional data?: Maybe<string>

    data of ParentImpact

  • Optional id?: Maybe<string>

    id of ParentImpact

  • Optional url?: Maybe<string>

    url of ParentImpact

ParentImpactCommitArgs

ParentImpactCommitArgs: object

ParentImpact-Node

Type declaration

ParentImpactCommitsArgs

ParentImpactCommitsArgs: object

ParentImpact-Node

Type declaration

Person

Person: object

Person-Node

Type declaration

  • Optional __typename?: "Person"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional chatId?: Maybe<ChatId>

    Person chatId ChatId

  • Optional emails?: Maybe<Array<Maybe<Email>>>

    Person emails Email

  • Optional forename?: Maybe<string>

    forename of Person

  • Optional gitHubId?: Maybe<GitHubId>

    Person gitHubId GitHubId

  • Optional id?: Maybe<string>

    id of Person

  • Optional name?: Maybe<string>

    name of Person

  • Optional preferences?: Maybe<Array<Maybe<PersonPreference>>>

    Return a person's preferences

  • Optional scmId?: Maybe<ScmId>

    Person scmId SCMId

  • Optional surname?: Maybe<string>

    surname of Person

  • Optional team?: Maybe<Team>

    Person team Team

PersonChatIdArgs

PersonChatIdArgs: object

Person-Node

Type declaration

PersonEmailsArgs

PersonEmailsArgs: object

Person-Node

Type declaration

PersonFieldsFragment

PersonFieldsFragment: object & object & object

PersonGitHubIdArgs

PersonGitHubIdArgs: object

Person-Node

Type declaration

PersonPreference

PersonPreference: object

A person's preferences as key/value pairs

Type declaration

  • Optional __typename?: "PersonPreference"
  • Optional name?: Maybe<string>

    The name of the preference

  • Optional value?: Maybe<string>

    The value of the preference

PersonScmIdArgs

PersonScmIdArgs: object

Person-Node

Type declaration

PersonTeamArgs

PersonTeamArgs: object

Person-Node

Type declaration

Pipeline

Pipeline: object

Pipeline-Node

Type declaration

  • Optional __typename?: "Pipeline"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    Pipeline commit Commit

  • Optional createdAt?: Maybe<string>

    createdAt of Pipeline

  • Optional finishedAt?: Maybe<string>

    finishedAt of Pipeline

  • Optional pipelineId?: Maybe<string>

    pipelineId of Pipeline

  • Optional provider?: Maybe<PipelineProvider>

    provider of Pipeline

  • Optional push?: Maybe<Push>

    Pipeline push Push

  • Optional repo?: Maybe<Repo>

    Pipeline repo Repo

  • Optional stages?: Maybe<Array<Maybe<Stage>>>

    Pipeline stages Stage

  • Optional status?: Maybe<PipelineStatus>

    status of Pipeline

PipelineCommitArgs

PipelineCommitArgs: object

Pipeline-Node

Type declaration

PipelinePushArgs

PipelinePushArgs: object

Pipeline-Node

Type declaration

PipelineRepoArgs

PipelineRepoArgs: object

Pipeline-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

PipelineStagesArgs

PipelineStagesArgs: object

Pipeline-Node

Type declaration

PullRequest

PullRequest: object

PullRequest-Node

Type declaration

  • Optional __typename?: "PullRequest"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional action?: Maybe<PullRequestAction>

    action of PullRequest

  • Optional assignees?: Maybe<Array<Maybe<ScmId>>>

    PullRequest assignees SCMId

  • Optional author?: Maybe<ScmId>

    PullRequest author SCMId

  • Optional base?: Maybe<Commit>

    PullRequest base Commit

  • Optional baseBranchName?: Maybe<string>

    baseBranchName of PullRequest

  • Optional body?: Maybe<string>

    body of PullRequest

  • Optional branch?: Maybe<Branch>

    PullRequest branch Branch

  • Optional branchName?: Maybe<string>

    branchName of PullRequest

  • Optional builds?: Maybe<Array<Maybe<Build>>>

    PullRequest builds Build

  • Optional closedAt?: Maybe<string>

    closedAt of PullRequest

  • Optional comments?: Maybe<Array<Maybe<Comment>>>

    PullRequest comments Comment

  • Optional commits?: Maybe<Array<Maybe<Commit>>>

    PullRequest commits Commit

  • Optional createdAt?: Maybe<string>

    createdAt of PullRequest

  • Optional destinationBranch?: Maybe<Branch>

    PullRequest destinationBranch Branch

  • Optional head?: Maybe<Commit>

    PullRequest head Commit

  • Optional id?: Maybe<string>

    id of PullRequest

  • Optional labels?: Maybe<Array<Maybe<Label>>>

    PullRequest labels Label

  • Optional lastAssignedBy?: Maybe<ScmId>

    PullRequest lastAssignedBy SCMId

  • Optional mergeCommit?: Maybe<Commit>

    PullRequest mergeCommit Commit

  • Optional mergeStatus?: Maybe<MergeStatus>

    mergeStatus of PullRequest

  • Optional merged?: Maybe<boolean>

    merged of PullRequest

  • Optional mergedAt?: Maybe<string>

    mergedAt of PullRequest

  • Optional merger?: Maybe<ScmId>

    PullRequest merger SCMId

  • Optional name?: Maybe<string>

    name of PullRequest

  • Optional number?: Maybe<number>

    number of PullRequest

  • Optional prId?: Maybe<string>

    prId of PullRequest

  • Optional repo?: Maybe<Repo>

    PullRequest repo Repo

  • Optional reviewers?: Maybe<Array<Maybe<ScmId>>>

    PullRequest reviewers SCMId

  • Optional reviews?: Maybe<Array<Maybe<Review>>>

    PullRequest reviews Review

  • Optional sourceBranch?: Maybe<Branch>

    PullRequest sourceBranch Branch

  • Optional state?: Maybe<string>

    state of PullRequest

  • Optional timestamp?: Maybe<string>

    timestamp of PullRequest

  • Optional title?: Maybe<string>

    title of PullRequest

  • Optional updatedAt?: Maybe<string>

    updatedAt of PullRequest

PullRequestAssigneesArgs

PullRequestAssigneesArgs: object

PullRequest-Node

Type declaration

PullRequestAuthorArgs

PullRequestAuthorArgs: object

PullRequest-Node

Type declaration

PullRequestBaseArgs

PullRequestBaseArgs: object

PullRequest-Node

Type declaration

PullRequestBranchArgs

PullRequestBranchArgs: object

PullRequest-Node

Type declaration

PullRequestBuildsArgs

PullRequestBuildsArgs: object

PullRequest-Node

Type declaration

PullRequestCommentsArgs

PullRequestCommentsArgs: object

PullRequest-Node

Type declaration

PullRequestCommitsArgs

PullRequestCommitsArgs: object

PullRequest-Node

Type declaration

PullRequestDestinationBranchArgs

PullRequestDestinationBranchArgs: object

PullRequest-Node

Type declaration

PullRequestHeadArgs

PullRequestHeadArgs: object

PullRequest-Node

Type declaration

PullRequestImpact

PullRequestImpact: object

PullRequestImpact-Node

Type declaration

  • Optional __typename?: "PullRequestImpact"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional data?: Maybe<string>

    data of PullRequestImpact

  • Optional id?: Maybe<string>

    id of PullRequestImpact

  • Optional pullRequest?: Maybe<PullRequest>

    PullRequestImpact pullRequest PullRequest

  • Optional url?: Maybe<string>

    url of PullRequestImpact

PullRequestImpactPullRequestArgs

PullRequestImpactPullRequestArgs: object

PullRequestImpact-Node

Type declaration

PullRequestLabelsArgs

PullRequestLabelsArgs: object

PullRequest-Node

Type declaration

PullRequestLastAssignedByArgs

PullRequestLastAssignedByArgs: object

PullRequest-Node

Type declaration

PullRequestMergeCommitArgs

PullRequestMergeCommitArgs: object

PullRequest-Node

Type declaration

PullRequestMergerArgs

PullRequestMergerArgs: object

PullRequest-Node

Type declaration

PullRequestRepoArgs

PullRequestRepoArgs: object

PullRequest-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

PullRequestReviewersArgs

PullRequestReviewersArgs: object

PullRequest-Node

Type declaration

PullRequestReviewsArgs

PullRequestReviewsArgs: object

PullRequest-Node

Type declaration

PullRequestSourceBranchArgs

PullRequestSourceBranchArgs: object

PullRequest-Node

Type declaration

Push

Push: object

Push-Node

Type declaration

PushAfterArgs

PushAfterArgs: object

Push-Node

Type declaration

PushBeforeArgs

PushBeforeArgs: object

Push-Node

Type declaration

PushBuildsArgs

PushBuildsArgs: object

Push-Node

Type declaration

PushCommitsArgs

PushCommitsArgs: object

Push-Node

Type declaration

PushFieldsFragment

PushFieldsFragment: object & object & object

PushPipelinesArgs

PushPipelinesArgs: object

Push-Node

Type declaration

PushRepoArgs

PushRepoArgs: object

Push-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

QueryType

QueryType: object

Type declaration

QueryTypeApplicationArgs

QueryTypeApplicationArgs: object

Type declaration

QueryTypeAtomistLogArgs

QueryTypeAtomistLogArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional category?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional level?: Maybe<Array<Maybe<string>>>
  • Optional message?: Maybe<Array<Maybe<string>>>
  • Optional team_id?: Maybe<Array<Maybe<string>>>
  • Optional timestamp?: Maybe<Array<Maybe<number>>>

QueryTypeBranchArgs

QueryTypeBranchArgs: object

Type declaration

QueryTypeBuildArgs

QueryTypeBuildArgs: object

Type declaration

QueryTypeCardArgs

QueryTypeCardArgs: object

Type declaration

QueryTypeChannelLinkArgs

QueryTypeChannelLinkArgs: object

Type declaration

QueryTypeChatChannelArgs

QueryTypeChatChannelArgs: object

Type declaration

QueryTypeChatIdArgs

QueryTypeChatIdArgs: object

Type declaration

QueryTypeChatTeamArgs

QueryTypeChatTeamArgs: object

Type declaration

QueryTypeCommentArgs

QueryTypeCommentArgs: object

Type declaration

QueryTypeCommitArgs

QueryTypeCommitArgs: object

Type declaration

QueryTypeCommitByShaArgs

QueryTypeCommitByShaArgs: object

Type declaration

  • sha: string

QueryTypeCommitIssueRelationshipArgs

QueryTypeCommitIssueRelationshipArgs: object

Type declaration

QueryTypeDeletedBranchArgs

QueryTypeDeletedBranchArgs: object

Type declaration

QueryTypeDeploymentArgs

QueryTypeDeploymentArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional environment?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ts?: Maybe<Array<Maybe<number>>>

QueryTypeDockerImageArgs

QueryTypeDockerImageArgs: object

Type declaration

QueryTypeEmailArgs

QueryTypeEmailArgs: object

Type declaration

QueryTypeFeedbackArgs

QueryTypeFeedbackArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional email?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional invocation_id?: Maybe<Array<Maybe<string>>>
  • Optional message?: Maybe<Array<Maybe<string>>>

QueryTypeFingerprintArgs

QueryTypeFingerprintArgs: object

Type declaration

QueryTypeGitHubIdArgs

QueryTypeGitHubIdArgs: object

Type declaration

QueryTypeGitHubOrgWebhookArgs

QueryTypeGitHubOrgWebhookArgs: object

Type declaration

QueryTypeGitHubProviderArgs

QueryTypeGitHubProviderArgs: object

Type declaration

QueryTypeHerokuAppArgs

QueryTypeHerokuAppArgs: object

Type declaration

QueryTypeImageLinkedArgs

QueryTypeImageLinkedArgs: object

Type declaration

QueryTypeIssueArgs

QueryTypeIssueArgs: object

Type declaration

QueryTypeIssueRelationshipArgs

QueryTypeIssueRelationshipArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional id?: Maybe<string>
  • Optional relationshipId?: Maybe<Array<Maybe<string>>>
  • Optional state?: Maybe<Array<Maybe<string>>>
  • Optional type?: Maybe<Array<Maybe<string>>>

QueryTypeJobArgs

QueryTypeJobArgs: object

Type declaration

QueryTypeK8ContainerArgs

QueryTypeK8ContainerArgs: object

Type declaration

QueryTypeK8PodArgs

QueryTypeK8PodArgs: object

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional baseName?: Maybe<string>
  • Optional baseNames?: Maybe<Array<Maybe<string>>>
  • Optional containersCrashLoopBackOff?: Maybe<boolean>
  • Optional containersCrashLoopBackOffs?: Maybe<Array<Maybe<boolean>>>
  • Optional envJSON?: Maybe<string>
  • Optional envJSONs?: Maybe<Array<Maybe<string>>>
  • Optional environment?: Maybe<string>
  • Optional environments?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_K8PodFilter>
  • Optional first?: Maybe<number>
  • Optional host?: Maybe<string>
  • Optional hosts?: Maybe<Array<Maybe<string>>>
  • Optional metadataJSON?: Maybe<string>
  • Optional metadataJSONs?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional namespace?: Maybe<string>
  • Optional namespaces?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>
  • Optional phase?: Maybe<string>
  • Optional phases?: Maybe<Array<Maybe<string>>>
  • Optional resourceVersion?: Maybe<number>
  • Optional resourceVersions?: Maybe<Array<Maybe<number>>>
  • Optional specsJSON?: Maybe<string>
  • Optional specsJSONs?: Maybe<Array<Maybe<string>>>
  • Optional state?: Maybe<string>
  • Optional states?: Maybe<Array<Maybe<string>>>
  • Optional statusJSON?: Maybe<string>
  • Optional statusJSONs?: Maybe<Array<Maybe<string>>>
  • Optional timestamp?: Maybe<string>
  • Optional timestamps?: Maybe<Array<Maybe<string>>>

QueryTypeLabelArgs

QueryTypeLabelArgs: object

Type declaration

QueryTypeLinkedRepoArgs

QueryTypeLinkedRepoArgs: object

Type declaration

  • name: string
  • owner: string
  • provider: string

QueryTypeManifestoSignatureArgs

QueryTypeManifestoSignatureArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional email?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional user?: Maybe<Array<Maybe<string>>>
  • Optional userId?: Maybe<Array<Maybe<string>>>
  • Optional userName?: Maybe<Array<Maybe<string>>>

QueryTypeNotificationArgs

QueryTypeNotificationArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional body?: Maybe<string>
  • Optional contentType?: Maybe<string>
  • Optional id?: Maybe<string>
  • Optional key?: Maybe<string>
  • Optional post?: Maybe<Array<Maybe<string>>>
  • Optional ts?: Maybe<number>
  • Optional ttl?: Maybe<Array<Maybe<number>>>

QueryTypeOrgArgs

QueryTypeOrgArgs: object

Type declaration

QueryTypeParentImpactArgs

QueryTypeParentImpactArgs: object

Type declaration

QueryTypePersonArgs

QueryTypePersonArgs: object

Type declaration

QueryTypePipelineArgs

QueryTypePipelineArgs: object

Type declaration

QueryTypePullRequestArgs

QueryTypePullRequestArgs: object

Type declaration

QueryTypePullRequestImpactArgs

QueryTypePullRequestImpactArgs: object

Type declaration

QueryTypePushArgs

QueryTypePushArgs: object

Type declaration

QueryTypePushByShaArgs

QueryTypePushByShaArgs: object

Type declaration

  • afterSha: string
  • branchName: string

QueryTypePushImpactArgs

QueryTypePushImpactArgs: object

Type declaration

QueryTypeReleaseArgs

QueryTypeReleaseArgs: object

Type declaration

QueryTypeRepoArgs

QueryTypeRepoArgs: object

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional first?: Maybe<number>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

QueryTypeReviewArgs

QueryTypeReviewArgs: object

Type declaration

QueryTypeScmIdArgs

QueryTypeScmIdArgs: object

Type declaration

QueryTypeScmProviderArgs

QueryTypeScmProviderArgs: object

Type declaration

QueryTypeSdmBuildIdentifierArgs

QueryTypeSdmBuildIdentifierArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional id?: Maybe<string>
  • Optional identifier?: Maybe<Array<Maybe<string>>>

QueryTypeSdmDeployEnablementArgs

QueryTypeSdmDeployEnablementArgs: object

Type declaration

QueryTypeSdmGoalArgs

QueryTypeSdmGoalArgs: object

Type declaration

QueryTypeSdmGoalDisplayArgs

QueryTypeSdmGoalDisplayArgs: object

Type declaration

QueryTypeSdmGoalSetArgs

QueryTypeSdmGoalSetArgs: object

Type declaration

QueryTypeSdmGoalSetBadgeArgs

QueryTypeSdmGoalSetBadgeArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional id?: Maybe<string>
  • Optional sdm?: Maybe<Array<Maybe<string>>>
  • Optional token?: Maybe<Array<Maybe<string>>>

QueryTypeSdmVersionArgs

QueryTypeSdmVersionArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional branch?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional sha?: Maybe<Array<Maybe<string>>>
  • Optional version?: Maybe<Array<Maybe<string>>>

QueryTypeSentryAlertArgs

QueryTypeSentryAlertArgs: object

Type declaration

  • Optional _after?: Maybe<number>
  • Optional _before?: Maybe<number>
  • Optional _first?: Maybe<number>
  • Optional _offset?: Maybe<number>
  • Optional _orderBy?: Maybe<string>
  • Optional _ordering?: Maybe<_Ordering>
  • Optional _search?: Maybe<string>
  • Optional culprit?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional level?: Maybe<Array<Maybe<string>>>
  • Optional message?: Maybe<Array<Maybe<string>>>
  • Optional project?: Maybe<Array<Maybe<string>>>
  • Optional project_name?: Maybe<Array<Maybe<string>>>
  • Optional url?: Maybe<Array<Maybe<string>>>

QueryTypeStageArgs

QueryTypeStageArgs: object

Type declaration

QueryTypeStatusArgs

QueryTypeStatusArgs: object

Type declaration

QueryTypeTagArgs

QueryTypeTagArgs: object

Type declaration

QueryTypeTeamArgs

QueryTypeTeamArgs: object

Type declaration

QueryTypeUserJoinedChannelArgs

QueryTypeUserJoinedChannelArgs: object

Type declaration

QueryTypeWebhookArgs

QueryTypeWebhookArgs: object

Type declaration

QueryTypeWorkflowArgs

QueryTypeWorkflowArgs: object

Type declaration

Release

Release: object

Release-Node

Type declaration

  • Optional __typename?: "Release"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional id?: Maybe<string>

    id of Release

  • Optional name?: Maybe<string>

    name of Release

  • Optional tag?: Maybe<Tag>

    Release tag Tag

  • Optional timestamp?: Maybe<string>

    timestamp of Release

ReleaseTagArgs

ReleaseTagArgs: object

Release-Node

Type declaration

Repo

Repo: object

Repo-Node

Type declaration

  • Optional __typename?: "Repo"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional allowMergeCommit?: Maybe<boolean>

    allowMergeCommit of Repo

  • Optional allowRebaseMerge?: Maybe<boolean>

    allowRebaseMerge of Repo

  • Optional allowSquashMerge?: Maybe<boolean>

    allowSquashMerge of Repo

  • Optional branches?: Maybe<Array<Maybe<Branch>>>

    Repo branches Branch

  • Optional channels?: Maybe<Array<Maybe<ChatChannel>>>

    Repo channels ChatChannel

  • Optional defaultBranch?: Maybe<string>

    defaultBranch of Repo

  • Optional gitHubId?: Maybe<string>

    gitHubId of Repo

  • Optional id?: Maybe<string>

    id of Repo

  • Optional issue?: Maybe<Array<Maybe<Issue>>>

    Repo issue Issue

  • Optional issues?: Maybe<Array<Maybe<Issue>>>

    Repo issues Issue

  • Optional labels?: Maybe<Array<Maybe<Label>>>

    Repo labels Label

  • Optional links?: Maybe<Array<Maybe<ChannelLink>>>

    Repo links ChannelLink

  • Optional name?: Maybe<string>

    name of Repo

  • Optional org?: Maybe<Org>

    Repo org Org

  • Optional owner?: Maybe<string>

    owner of Repo

  • Optional pullRequest?: Maybe<Array<Maybe<PullRequest>>>

    Repo pullRequest PullRequest

  • Optional pullRequests?: Maybe<Array<Maybe<PullRequest>>>

    Repo pullRequests PullRequest

  • Optional repoId?: Maybe<string>

    repoId of Repo

  • Optional webhook?: Maybe<Webhook>

    Repo webhook Webhook

RepoBranchesArgs

RepoBranchesArgs: object

Repo-Node

Type declaration

RepoChannelsArgs

RepoChannelsArgs: object

Repo-Node

Type declaration

RepoIssueArgs

RepoIssueArgs: object

Repo-Node

Type declaration

RepoIssuesArgs

RepoIssuesArgs: object

Repo-Node

Type declaration

RepoLabelsArgs

RepoLabelsArgs: object

Repo-Node

Type declaration

RepoLinksArgs

RepoLinksArgs: object

Repo-Node

Type declaration

RepoLogin

RepoLogin: object

a GitHub Owner (like an Org) can set a login to be used for background tasks

Type declaration

  • Optional __typename?: "RepoLogin"
  • Optional login?: Maybe<string>

    The login that should be used

  • Optional owner?: Maybe<string>

    The owner name for the Organization/Team

  • Optional providerId?: Maybe<string>

    The id of the git provider for this Owner

  • Optional repo?: Maybe<string>

    The repository name

RepoOnboarded

RepoOnboarded: object

The data for an existing Repo has been loaded and is ready for querying

Type declaration

  • Optional __typename?: "RepoOnboarded"
  • repo: Repo

    GitHub Repository

RepoOrgArgs

RepoOrgArgs: object

Repo-Node

Type declaration

RepoPullRequestArgs

RepoPullRequestArgs: object

Repo-Node

Type declaration

RepoPullRequestsArgs

RepoPullRequestsArgs: object

Repo-Node

Type declaration

RepoWebhookArgs

RepoWebhookArgs: object

Repo-Node

Type declaration

Review

Review: object

Review-Node

Type declaration

  • Optional __typename?: "Review"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional body?: Maybe<string>

    body of Review

  • Optional by?: Maybe<Array<Maybe<ScmId>>>

    Review by SCMId

  • Optional comments?: Maybe<Array<Maybe<Comment>>>

    Review comments Comment

  • Optional commit?: Maybe<Commit>

    Review commit Commit

  • Optional gitHubId?: Maybe<string>

    gitHubId of Review

  • Optional htmlUrl?: Maybe<string>

    htmlUrl of Review

  • Optional id?: Maybe<string>

    id of Review

  • Optional pullRequest?: Maybe<PullRequest>

    Review pullRequest PullRequest

  • Optional reviewId?: Maybe<string>

    reviewId of Review

  • Optional state?: Maybe<ReviewState>

    state of Review

  • Optional submittedAt?: Maybe<string>

    submittedAt of Review

ReviewByArgs

ReviewByArgs: object

Review-Node

Type declaration

ReviewCommentsArgs

ReviewCommentsArgs: object

Review-Node

Type declaration

ReviewCommitArgs

ReviewCommitArgs: object

Review-Node

Type declaration

ReviewPullRequestArgs

ReviewPullRequestArgs: object

Review-Node

Type declaration

Scalars

Scalars: object

All built-in and custom scalars, mapped to their actual values

Type declaration

  • Boolean: boolean
  • Float: number
  • ID: string
  • Int: number
  • Long: any

    Long type

  • String: string

ScmId

ScmId: object

SCMId-Node

Type declaration

  • Optional __typename?: "SCMId"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional avatar?: Maybe<string>

    avatar of SCMId

  • Optional emails?: Maybe<Array<Maybe<Email>>>

    SCMId emails Email

  • Optional login?: Maybe<string>

    login of SCMId

  • Optional name?: Maybe<string>

    name of SCMId

  • Optional person?: Maybe<Person>

    SCMId person Person

  • Optional provider?: Maybe<Array<Maybe<GitHubProvider>>>

    SCMId provider GitHubProvider

  • Optional scmProvider?: Maybe<ScmProvider>

    SCMId scmProvider SCMProvider

ScmIdEmailsArgs

ScmIdEmailsArgs: object

SCMId-Node

Type declaration

ScmIdPersonArgs

ScmIdPersonArgs: object

SCMId-Node

Type declaration

ScmIdProviderArgs

ScmIdProviderArgs: object

SCMId-Node

Type declaration

ScmIdScmProviderArgs

ScmIdScmProviderArgs: object

SCMId-Node

Type declaration

ScmProvider

ScmProvider: object

SCMProvider-Node

Type declaration

  • Optional __typename?: "SCMProvider"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional apiUrl?: Maybe<string>

    apiUrl of SCMProvider

  • Optional gitUrl?: Maybe<string>

    gitUrl of SCMProvider

  • Optional id?: Maybe<string>

    id of SCMProvider

  • Optional private?: Maybe<boolean>

    private of SCMProvider

  • Optional providerId?: Maybe<string>

    providerId of SCMProvider

  • Optional providerType?: Maybe<ProviderType>

    providerType of SCMProvider

  • Optional team?: Maybe<Team>

    SCMProvider team Team

  • Optional url?: Maybe<string>

    url of SCMProvider

ScmProviderTeamArgs

ScmProviderTeamArgs: object

SCMProvider-Node

Type declaration

SdmBuildIdentifier

SdmBuildIdentifier: object

Type declaration

SdmBuildIdentifierForRepoQuery

SdmBuildIdentifierForRepoQuery: object & object

SdmBuildIdentifierForRepoQueryVariables

SdmBuildIdentifierForRepoQueryVariables: object

Type declaration

  • Optional name?: Maybe<Array<string>>
  • Optional owner?: Maybe<Array<string>>
  • Optional providerId?: Maybe<Array<string>>

SdmBuildIdentifierRepoArgs

SdmBuildIdentifierRepoArgs: object

Type declaration

SdmBuildIdentifierRepository

SdmBuildIdentifierRepository: object

Type declaration

  • Optional __typename?: "SdmBuildIdentifierRepository"
  • Optional name?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>

SdmCondition

SdmCondition: object

Type declaration

  • Optional __typename?: "SdmCondition"
  • Optional environment?: Maybe<string>
  • Optional name?: Maybe<string>
  • Optional uniqueName?: Maybe<string>

SdmDeployEnablement

SdmDeployEnablement: object

Type declaration

  • Optional __typename?: "SdmDeployEnablement"
  • Optional id?: Maybe<string>

    The ID of this SdmDeployEnablement

  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>
  • Optional repo?: Maybe<string>
  • Optional state?: Maybe<SdmDeployState>

SdmExternalUrl

SdmExternalUrl: object

Type declaration

  • Optional __typename?: "SdmExternalUrl"
  • Optional label?: Maybe<string>
  • Optional url?: Maybe<string>

SdmGoal

SdmGoal: object

Type declaration

SdmGoalDisplay

SdmGoalDisplay: object

Type declaration

SdmGoalFulfillment

SdmGoalFulfillment: object

Type declaration

  • Optional __typename?: "SdmGoalFulfillment"
  • Optional method?: Maybe<string>
  • Optional name?: Maybe<string>

SdmGoalFulfillmentArgs

SdmGoalFulfillmentArgs: object

Type declaration

SdmGoalName

SdmGoalName: object

Type declaration

  • Optional __typename?: "SdmGoalName"
  • Optional name?: Maybe<string>
  • Optional uniqueName?: Maybe<string>

SdmGoalRepoArgs

SdmGoalRepoArgs: object

Type declaration

SdmGoalSet

SdmGoalSet: object

Type declaration

SdmGoalSetBadge

SdmGoalSetBadge: object

Type declaration

SdmGoalSetBadgeRepoArgs

SdmGoalSetBadgeRepoArgs: object

Type declaration

SdmGoalSetBadgeRepository

SdmGoalSetBadgeRepository: object

Type declaration

  • Optional __typename?: "SdmGoalSetBadgeRepository"
  • Optional name?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>

SdmGoalSetRepoArgs

SdmGoalSetRepoArgs: object

Type declaration

SdmProvenance

SdmProvenance: object

Type declaration

  • Optional __typename?: "SdmProvenance"
  • Optional channelId?: Maybe<string>
  • Optional correlationId?: Maybe<string>
  • Optional name?: Maybe<string>
  • Optional registration?: Maybe<string>
  • Optional ts?: Maybe<number>
  • Optional userId?: Maybe<string>
  • Optional version?: Maybe<string>

SdmRepository

SdmRepository: object

Type declaration

  • Optional __typename?: "SdmRepository"
  • Optional name?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>

SdmVersion

SdmVersion: object

Type declaration

  • Optional __typename?: "SdmVersion"
  • Optional branch?: Maybe<string>
  • Optional id?: Maybe<string>

    The ID of this SdmVersion

  • Optional repo?: Maybe<SdmVersionRepository>
  • Optional sha?: Maybe<string>
  • Optional version?: Maybe<string>

SdmVersionRepoArgs

SdmVersionRepoArgs: object

Type declaration

SdmVersionRepository

SdmVersionRepository: object

Type declaration

  • Optional __typename?: "SdmVersionRepository"
  • Optional name?: Maybe<string>
  • Optional owner?: Maybe<string>
  • Optional providerId?: Maybe<string>

SentryAlert

SentryAlert: object

Type declaration

  • Optional __typename?: "SentryAlert"
  • Optional commit?: Maybe<Commit>
  • Optional culprit?: Maybe<string>
  • Optional event?: Maybe<SentryEvent>
  • Optional id?: Maybe<string>

    The ID of this SentryAlert

  • Optional level?: Maybe<string>
  • Optional message?: Maybe<string>
  • Optional project?: Maybe<string>
  • Optional project_name?: Maybe<string>
  • Optional url?: Maybe<string>

SentryEvent

SentryEvent: object

Type declaration

SentryEventExtra

SentryEventExtra: object

Type declaration

  • Optional __typename?: "SentryEventExtra"
  • Optional artifact?: Maybe<string>
  • Optional correlation_id?: Maybe<string>
  • Optional environment?: Maybe<string>
  • Optional git_owner?: Maybe<string>
  • Optional git_repo?: Maybe<string>
  • Optional git_sha?: Maybe<string>
  • Optional invocation_id?: Maybe<string>
  • Optional operation_name?: Maybe<string>
  • Optional operation_type?: Maybe<string>
  • Optional team_id?: Maybe<string>
  • Optional team_name?: Maybe<string>
  • Optional version?: Maybe<string>

SentryEventExtraArgs

SentryEventExtraArgs: object

Type declaration

  • Optional git_sha?: Maybe<string>

SlackChannel

SlackChannel: object

A slack channel

Type declaration

  • Optional __typename?: "SlackChannel"
  • Optional chatTeamId?: Maybe<string>

    The id of the chat team

  • Optional id?: Maybe<string>

    The id of the channel

  • Optional name?: Maybe<string>

    The name of the channel

Stage

Stage: object

Stage-Node

Type declaration

  • Optional __typename?: "Stage"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional jobs?: Maybe<Array<Maybe<Job>>>

    Stage jobs Job

  • Optional name?: Maybe<string>

    name of Stage

  • Optional pipeline?: Maybe<Pipeline>

    Stage pipeline Pipeline

StageJobsArgs

StageJobsArgs: object

Stage-Node

Type declaration

StagePipelineArgs

StagePipelineArgs: object

Stage-Node

Type declaration

Status

Status: object

Status-Node

Type declaration

  • Optional __typename?: "Status"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional commit?: Maybe<Commit>

    Status commit Commit

  • Optional context?: Maybe<string>

    context of Status

  • Optional description?: Maybe<string>

    description of Status

  • Optional id?: Maybe<string>

    id of Status

  • Optional state?: Maybe<StatusState>

    state of Status

  • Optional targetUrl?: Maybe<string>

    targetUrl of Status

  • Optional timestamp?: Maybe<string>

    timestamp of Status

StatusCommitArgs

StatusCommitArgs: object

Status-Node

Type declaration

SubscriptionType

SubscriptionType: object

Type declaration

SubscriptionTypeApplicationArgs

SubscriptionTypeApplicationArgs: object

Type declaration

SubscriptionTypeAtomistLogArgs

SubscriptionTypeAtomistLogArgs: object

Type declaration

SubscriptionTypeBranchArgs

SubscriptionTypeBranchArgs: object

Type declaration

SubscriptionTypeBuildArgs

SubscriptionTypeBuildArgs: object

Type declaration

SubscriptionTypeCardArgs

SubscriptionTypeCardArgs: object

Type declaration

SubscriptionTypeChannelLinkArgs

SubscriptionTypeChannelLinkArgs: object

Type declaration

SubscriptionTypeChatChannelArgs

SubscriptionTypeChatChannelArgs: object

Type declaration

SubscriptionTypeChatIdArgs

SubscriptionTypeChatIdArgs: object

Type declaration

SubscriptionTypeChatTeamArgs

SubscriptionTypeChatTeamArgs: object

Type declaration

SubscriptionTypeCommentArgs

SubscriptionTypeCommentArgs: object

Type declaration

SubscriptionTypeCommitArgs

SubscriptionTypeCommitArgs: object

Type declaration

SubscriptionTypeCommitIssueRelationshipArgs

SubscriptionTypeCommitIssueRelationshipArgs: object

Type declaration

SubscriptionTypeDeletedBranchArgs

SubscriptionTypeDeletedBranchArgs: object

Type declaration

SubscriptionTypeDeploymentArgs

SubscriptionTypeDeploymentArgs: object

Type declaration

SubscriptionTypeDockerImageArgs

SubscriptionTypeDockerImageArgs: object

Type declaration

SubscriptionTypeEmailArgs

SubscriptionTypeEmailArgs: object

Type declaration

SubscriptionTypeFeedbackArgs

SubscriptionTypeFeedbackArgs: object

Type declaration

SubscriptionTypeFingerprintArgs

SubscriptionTypeFingerprintArgs: object

Type declaration

SubscriptionTypeGitHubIdArgs

SubscriptionTypeGitHubIdArgs: object

Type declaration

SubscriptionTypeGitHubOrgWebhookArgs

SubscriptionTypeGitHubOrgWebhookArgs: object

Type declaration

SubscriptionTypeGitHubProviderArgs

SubscriptionTypeGitHubProviderArgs: object

Type declaration

SubscriptionTypeHerokuAppArgs

SubscriptionTypeHerokuAppArgs: object

Type declaration

SubscriptionTypeImageLinkedArgs

SubscriptionTypeImageLinkedArgs: object

Type declaration

SubscriptionTypeIssueArgs

SubscriptionTypeIssueArgs: object

Type declaration

SubscriptionTypeIssueRelationshipArgs

SubscriptionTypeIssueRelationshipArgs: object

Type declaration

SubscriptionTypeJobArgs

SubscriptionTypeJobArgs: object

Type declaration

SubscriptionTypeK8ContainerArgs

SubscriptionTypeK8ContainerArgs: object

Type declaration

SubscriptionTypeK8PodArgs

SubscriptionTypeK8PodArgs: object

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional baseName?: Maybe<string>
  • Optional baseNames?: Maybe<Array<Maybe<string>>>
  • Optional containersCrashLoopBackOff?: Maybe<boolean>
  • Optional containersCrashLoopBackOffs?: Maybe<Array<Maybe<boolean>>>
  • Optional envJSON?: Maybe<string>
  • Optional envJSONs?: Maybe<Array<Maybe<string>>>
  • Optional environment?: Maybe<string>
  • Optional environments?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_K8PodFilter>
  • Optional first?: Maybe<number>
  • Optional host?: Maybe<string>
  • Optional hosts?: Maybe<Array<Maybe<string>>>
  • Optional metadataJSON?: Maybe<string>
  • Optional metadataJSONs?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional namespace?: Maybe<string>
  • Optional namespaces?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>
  • Optional phase?: Maybe<string>
  • Optional phases?: Maybe<Array<Maybe<string>>>
  • Optional resourceVersion?: Maybe<number>
  • Optional resourceVersions?: Maybe<Array<Maybe<number>>>
  • Optional specsJSON?: Maybe<string>
  • Optional specsJSONs?: Maybe<Array<Maybe<string>>>
  • Optional state?: Maybe<string>
  • Optional states?: Maybe<Array<Maybe<string>>>
  • Optional statusJSON?: Maybe<string>
  • Optional statusJSONs?: Maybe<Array<Maybe<string>>>
  • Optional timestamp?: Maybe<string>
  • Optional timestamps?: Maybe<Array<Maybe<string>>>

SubscriptionTypeLabelArgs

SubscriptionTypeLabelArgs: object

Type declaration

SubscriptionTypeManifestoSignatureArgs

SubscriptionTypeManifestoSignatureArgs: object

Type declaration

SubscriptionTypeNotificationArgs

SubscriptionTypeNotificationArgs: object

Type declaration

  • Optional body?: Maybe<string>
  • Optional contentType?: Maybe<string>
  • Optional key?: Maybe<string>
  • Optional post?: Maybe<Array<Maybe<string>>>
  • Optional ts?: Maybe<number>
  • Optional ttl?: Maybe<Array<Maybe<number>>>

SubscriptionTypeOrgArgs

SubscriptionTypeOrgArgs: object

Type declaration

SubscriptionTypeParentImpactArgs

SubscriptionTypeParentImpactArgs: object

Type declaration

SubscriptionTypePersonArgs

SubscriptionTypePersonArgs: object

Type declaration

SubscriptionTypePipelineArgs

SubscriptionTypePipelineArgs: object

Type declaration

SubscriptionTypePullRequestArgs

SubscriptionTypePullRequestArgs: object

Type declaration

SubscriptionTypePullRequestImpactArgs

SubscriptionTypePullRequestImpactArgs: object

Type declaration

SubscriptionTypePushArgs

SubscriptionTypePushArgs: object

Type declaration

SubscriptionTypePushImpactArgs

SubscriptionTypePushImpactArgs: object

Type declaration

SubscriptionTypeReleaseArgs

SubscriptionTypeReleaseArgs: object

Type declaration

SubscriptionTypeRepoArgs

SubscriptionTypeRepoArgs: object

Type declaration

  • Optional _id?: Maybe<any>
  • Optional _ids?: Maybe<Array<Maybe<any>>>
  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional first?: Maybe<number>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional offset?: Maybe<number>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

SubscriptionTypeReviewArgs

SubscriptionTypeReviewArgs: object

Type declaration

SubscriptionTypeScmIdArgs

SubscriptionTypeScmIdArgs: object

Type declaration

SubscriptionTypeScmProviderArgs

SubscriptionTypeScmProviderArgs: object

Type declaration

SubscriptionTypeSdmBuildIdentifierArgs

SubscriptionTypeSdmBuildIdentifierArgs: object

Type declaration

  • Optional identifier?: Maybe<Array<Maybe<string>>>

SubscriptionTypeSdmDeployEnablementArgs

SubscriptionTypeSdmDeployEnablementArgs: object

Type declaration

SubscriptionTypeSdmGoalArgs

SubscriptionTypeSdmGoalArgs: object

Type declaration

SubscriptionTypeSdmGoalDisplayArgs

SubscriptionTypeSdmGoalDisplayArgs: object

Type declaration

SubscriptionTypeSdmGoalSetArgs

SubscriptionTypeSdmGoalSetArgs: object

Type declaration

SubscriptionTypeSdmGoalSetBadgeArgs

SubscriptionTypeSdmGoalSetBadgeArgs: object

Type declaration

SubscriptionTypeSdmVersionArgs

SubscriptionTypeSdmVersionArgs: object

Type declaration

SubscriptionTypeSentryAlertArgs

SubscriptionTypeSentryAlertArgs: object

Type declaration

SubscriptionTypeStageArgs

SubscriptionTypeStageArgs: object

Type declaration

SubscriptionTypeStatusArgs

SubscriptionTypeStatusArgs: object

Type declaration

SubscriptionTypeTagArgs

SubscriptionTypeTagArgs: object

Type declaration

SubscriptionTypeTeamArgs

SubscriptionTypeTeamArgs: object

Type declaration

SubscriptionTypeUserJoinedChannelArgs

SubscriptionTypeUserJoinedChannelArgs: object

Type declaration

SubscriptionTypeWebhookArgs

SubscriptionTypeWebhookArgs: object

Type declaration

SubscriptionTypeWorkflowArgs

SubscriptionTypeWorkflowArgs: object

Type declaration

Tag

Tag: object

Tag-Node

Type declaration

  • Optional __typename?: "Tag"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional builds?: Maybe<Array<Maybe<Build>>>

    Tag builds Build

  • Optional commit?: Maybe<Commit>

    Tag commit Commit

  • Optional containers?: Maybe<Array<Maybe<DockerImage>>>

    Tag containers DockerImage

  • Optional description?: Maybe<string>

    description of Tag

  • Optional id?: Maybe<string>

    id of Tag

  • Optional name?: Maybe<string>

    name of Tag

  • Optional ref?: Maybe<string>

    ref of Tag

  • Optional release?: Maybe<Release>

    Tag release Release

  • Optional timestamp?: Maybe<string>

    timestamp of Tag

TagBuildsArgs

TagBuildsArgs: object

Tag-Node

Type declaration

TagCommitArgs

TagCommitArgs: object

Tag-Node

Type declaration

TagContainersArgs

TagContainersArgs: object

Tag-Node

Type declaration

TagReleaseArgs

TagReleaseArgs: object

Tag-Node

Type declaration

Team

Team: object

Team-Node

Type declaration

  • Optional __typename?: "Team"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional chatTeams?: Maybe<Array<Maybe<ChatTeam>>>

    Team chatTeams ChatTeam

  • Optional createdAt?: Maybe<string>

    createdAt of Team

  • Optional description?: Maybe<string>

    description of Team

  • Optional iconUrl?: Maybe<string>

    iconUrl of Team

  • Optional id?: Maybe<string>

    id of Team

  • Optional name?: Maybe<string>

    name of Team

  • Optional orgs?: Maybe<Array<Maybe<Org>>>

    Team orgs Org

  • Optional persons?: Maybe<Array<Maybe<Person>>>

    Team persons Person

  • Optional providers?: Maybe<Array<Maybe<GitHubProvider>>>

    Team providers GitHubProvider

  • Optional scmProviders?: Maybe<Array<Maybe<ScmProvider>>>

    Team scmProviders SCMProvider

TeamChatTeamsArgs

TeamChatTeamsArgs: object

Team-Node

Type declaration

TeamOrgsArgs

TeamOrgsArgs: object

Team-Node

Type declaration

TeamPersonsArgs

TeamPersonsArgs: object

Team-Node

Type declaration

TeamPreference

TeamPreference: object

A team's preferences as key/value pairs

Type declaration

  • Optional __typename?: "TeamPreference"
  • Optional name?: Maybe<string>

    The name of the preference

  • Optional value?: Maybe<string>

    The value of the preference

TeamProvidersArgs

TeamProvidersArgs: object

Team-Node

Type declaration

TeamScmProvidersArgs

TeamScmProvidersArgs: object

Team-Node

Type declaration

UserJoinedChannel

UserJoinedChannel: object

UserJoinedChannel-Node

Type declaration

  • Optional __typename?: "UserJoinedChannel"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional channel?: Maybe<ChatChannel>

    UserJoinedChannel channel ChatChannel

  • Optional id?: Maybe<string>

    id of UserJoinedChannel

  • Optional user?: Maybe<ChatId>

    UserJoinedChannel user ChatId

UserJoinedChannelChannelArgs

UserJoinedChannelChannelArgs: object

UserJoinedChannel-Node

Type declaration

UserJoinedChannelUserArgs

UserJoinedChannelUserArgs: object

UserJoinedChannel-Node

Type declaration

UserPreference

UserPreference: object

A user's preferences as key/value pairs

Type declaration

  • Optional __typename?: "UserPreference"
  • Optional name?: Maybe<string>

    The name of the preference

  • Optional value?: Maybe<string>

    The value of the preference

Webhook

Webhook: object

Webhook-Node

Type declaration

  • Optional __typename?: "Webhook"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional id?: Maybe<string>

    id of Webhook

  • Optional org?: Maybe<Org>

    Webhook org Org

  • Optional repo?: Maybe<Repo>

    Webhook repo Repo

  • Optional url?: Maybe<string>

    url of Webhook

  • Optional webhookType?: Maybe<WebhookType>

    webhookType of Webhook

WebhookOrgArgs

WebhookOrgArgs: object

Webhook-Node

Type declaration

WebhookRepoArgs

WebhookRepoArgs: object

Webhook-Node

Type declaration

  • Optional allowMergeCommit?: Maybe<boolean>
  • Optional allowMergeCommits?: Maybe<Array<Maybe<boolean>>>
  • Optional allowRebaseMerge?: Maybe<boolean>
  • Optional allowRebaseMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional allowSquashMerge?: Maybe<boolean>
  • Optional allowSquashMerges?: Maybe<Array<Maybe<boolean>>>
  • Optional defaultBranch?: Maybe<string>
  • Optional defaultBranchs?: Maybe<Array<Maybe<string>>>
  • Optional filter?: Maybe<_RepoFilter>
  • Optional gitHubId?: Maybe<string>
  • Optional gitHubIds?: Maybe<Array<Maybe<string>>>
  • Optional id?: Maybe<string>
  • Optional ids?: Maybe<Array<Maybe<string>>>
  • Optional name?: Maybe<string>
  • Optional names?: Maybe<Array<Maybe<string>>>
  • Optional orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>
  • Optional owner?: Maybe<string>
  • Optional owners?: Maybe<Array<Maybe<string>>>
  • Optional repoId?: Maybe<string>
  • Optional repoIds?: Maybe<Array<Maybe<string>>>

Workflow

Workflow: object

Workflow-Node

Type declaration

  • Optional __typename?: "Workflow"
  • Optional _id?: Maybe<any>

    internal node id

  • Optional builds?: Maybe<Array<Maybe<Build>>>

    Workflow builds Build

  • Optional config?: Maybe<string>

    config of Workflow

  • Optional id?: Maybe<string>

    id of Workflow

  • Optional name?: Maybe<string>

    name of Workflow

  • Optional provider?: Maybe<string>

    provider of Workflow

  • Optional workflowId?: Maybe<string>

    workflowId of Workflow

WorkflowBuildsArgs

WorkflowBuildsArgs: object

Workflow-Node

Type declaration

_ApplicationFilter

_ApplicationFilter: object

Filter Input Type for Application

Type declaration

  • Optional AND?: Maybe<Array<_ApplicationFilter>>

    AND

  • Optional OR?: Maybe<Array<_ApplicationFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commits?: Maybe<_CommitFilter>

    commits

  • Optional commits_every?: Maybe<_CommitFilter>

    commits_every

  • Optional commits_in?: Maybe<_CommitFilter>

    commits_in

  • Optional commits_none?: Maybe<_CommitFilter>

    commits_none

  • Optional commits_not?: Maybe<_CommitFilter>

    commits_not

  • Optional commits_not_in?: Maybe<_CommitFilter>

    commits_not_in

  • Optional commits_single?: Maybe<_CommitFilter>

    commits_single

  • Optional commits_some?: Maybe<_CommitFilter>

    commits_some

  • Optional data?: Maybe<string>

    data

  • Optional data_contains?: Maybe<string>

    data_contains

  • Optional data_ends_with?: Maybe<string>

    data_ends_with

  • Optional data_gt?: Maybe<string>

    data_gt

  • Optional data_gte?: Maybe<string>

    data_gte

  • Optional data_in?: Maybe<Array<string>>

    data_in

  • Optional data_lt?: Maybe<string>

    data_lt

  • Optional data_lte?: Maybe<string>

    data_lte

  • Optional data_not?: Maybe<string>

    data_not

  • Optional data_not_contains?: Maybe<string>

    data_not_contains

  • Optional data_not_ends_with?: Maybe<string>

    data_not_ends_with

  • Optional data_not_in?: Maybe<Array<string>>

    data_not_in

  • Optional data_not_starts_with?: Maybe<string>

    data_not_starts_with

  • Optional data_starts_with?: Maybe<string>

    data_starts_with

  • Optional domain?: Maybe<string>

    domain

  • Optional domain_contains?: Maybe<string>

    domain_contains

  • Optional domain_ends_with?: Maybe<string>

    domain_ends_with

  • Optional domain_gt?: Maybe<string>

    domain_gt

  • Optional domain_gte?: Maybe<string>

    domain_gte

  • Optional domain_in?: Maybe<Array<string>>

    domain_in

  • Optional domain_lt?: Maybe<string>

    domain_lt

  • Optional domain_lte?: Maybe<string>

    domain_lte

  • Optional domain_not?: Maybe<string>

    domain_not

  • Optional domain_not_contains?: Maybe<string>

    domain_not_contains

  • Optional domain_not_ends_with?: Maybe<string>

    domain_not_ends_with

  • Optional domain_not_in?: Maybe<Array<string>>

    domain_not_in

  • Optional domain_not_starts_with?: Maybe<string>

    domain_not_starts_with

  • Optional domain_starts_with?: Maybe<string>

    domain_starts_with

  • Optional host?: Maybe<string>

    host

  • Optional host_contains?: Maybe<string>

    host_contains

  • Optional host_ends_with?: Maybe<string>

    host_ends_with

  • Optional host_gt?: Maybe<string>

    host_gt

  • Optional host_gte?: Maybe<string>

    host_gte

  • Optional host_in?: Maybe<Array<string>>

    host_in

  • Optional host_lt?: Maybe<string>

    host_lt

  • Optional host_lte?: Maybe<string>

    host_lte

  • Optional host_not?: Maybe<string>

    host_not

  • Optional host_not_contains?: Maybe<string>

    host_not_contains

  • Optional host_not_ends_with?: Maybe<string>

    host_not_ends_with

  • Optional host_not_in?: Maybe<Array<string>>

    host_not_in

  • Optional host_not_starts_with?: Maybe<string>

    host_not_starts_with

  • Optional host_starts_with?: Maybe<string>

    host_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional state?: Maybe<string>

    state

  • Optional state_contains?: Maybe<string>

    state_contains

  • Optional state_ends_with?: Maybe<string>

    state_ends_with

  • Optional state_gt?: Maybe<string>

    state_gt

  • Optional state_gte?: Maybe<string>

    state_gte

  • Optional state_in?: Maybe<Array<string>>

    state_in

  • Optional state_lt?: Maybe<string>

    state_lt

  • Optional state_lte?: Maybe<string>

    state_lte

  • Optional state_not?: Maybe<string>

    state_not

  • Optional state_not_contains?: Maybe<string>

    state_not_contains

  • Optional state_not_ends_with?: Maybe<string>

    state_not_ends_with

  • Optional state_not_in?: Maybe<Array<string>>

    state_not_in

  • Optional state_not_starts_with?: Maybe<string>

    state_not_starts_with

  • Optional state_starts_with?: Maybe<string>

    state_starts_with

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_BranchFilter

_BranchFilter: object

Filter Input Type for Branch

Type declaration

  • Optional AND?: Maybe<Array<_BranchFilter>>

    AND

  • Optional OR?: Maybe<Array<_BranchFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional isRemote?: Maybe<boolean>

    isRemote

  • Optional isRemote_not?: Maybe<boolean>

    isRemote_not

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional pullRequests?: Maybe<_PullRequestFilter>

    pullRequests

  • Optional pullRequests_every?: Maybe<_PullRequestFilter>

    pullRequests_every

  • Optional pullRequests_in?: Maybe<_PullRequestFilter>

    pullRequests_in

  • Optional pullRequests_none?: Maybe<_PullRequestFilter>

    pullRequests_none

  • Optional pullRequests_not?: Maybe<_PullRequestFilter>

    pullRequests_not

  • Optional pullRequests_not_in?: Maybe<_PullRequestFilter>

    pullRequests_not_in

  • Optional pullRequests_single?: Maybe<_PullRequestFilter>

    pullRequests_single

  • Optional pullRequests_some?: Maybe<_PullRequestFilter>

    pullRequests_some

  • Optional remoteRepoHtmlUrl?: Maybe<string>

    remoteRepoHtmlUrl

  • Optional remoteRepoHtmlUrl_contains?: Maybe<string>

    remoteRepoHtmlUrl_contains

  • Optional remoteRepoHtmlUrl_ends_with?: Maybe<string>

    remoteRepoHtmlUrl_ends_with

  • Optional remoteRepoHtmlUrl_gt?: Maybe<string>

    remoteRepoHtmlUrl_gt

  • Optional remoteRepoHtmlUrl_gte?: Maybe<string>

    remoteRepoHtmlUrl_gte

  • Optional remoteRepoHtmlUrl_in?: Maybe<Array<string>>

    remoteRepoHtmlUrl_in

  • Optional remoteRepoHtmlUrl_lt?: Maybe<string>

    remoteRepoHtmlUrl_lt

  • Optional remoteRepoHtmlUrl_lte?: Maybe<string>

    remoteRepoHtmlUrl_lte

  • Optional remoteRepoHtmlUrl_not?: Maybe<string>

    remoteRepoHtmlUrl_not

  • Optional remoteRepoHtmlUrl_not_contains?: Maybe<string>

    remoteRepoHtmlUrl_not_contains

  • Optional remoteRepoHtmlUrl_not_ends_with?: Maybe<string>

    remoteRepoHtmlUrl_not_ends_with

  • Optional remoteRepoHtmlUrl_not_in?: Maybe<Array<string>>

    remoteRepoHtmlUrl_not_in

  • Optional remoteRepoHtmlUrl_not_starts_with?: Maybe<string>

    remoteRepoHtmlUrl_not_starts_with

  • Optional remoteRepoHtmlUrl_starts_with?: Maybe<string>

    remoteRepoHtmlUrl_starts_with

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_BuildFilter

_BuildFilter: object

Filter Input Type for Build

Type declaration

  • Optional AND?: Maybe<Array<_BuildFilter>>

    AND

  • Optional OR?: Maybe<Array<_BuildFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional buildId?: Maybe<string>

    buildId

  • Optional buildId_contains?: Maybe<string>

    buildId_contains

  • Optional buildId_ends_with?: Maybe<string>

    buildId_ends_with

  • Optional buildId_gt?: Maybe<string>

    buildId_gt

  • Optional buildId_gte?: Maybe<string>

    buildId_gte

  • Optional buildId_in?: Maybe<Array<string>>

    buildId_in

  • Optional buildId_lt?: Maybe<string>

    buildId_lt

  • Optional buildId_lte?: Maybe<string>

    buildId_lte

  • Optional buildId_not?: Maybe<string>

    buildId_not

  • Optional buildId_not_contains?: Maybe<string>

    buildId_not_contains

  • Optional buildId_not_ends_with?: Maybe<string>

    buildId_not_ends_with

  • Optional buildId_not_in?: Maybe<Array<string>>

    buildId_not_in

  • Optional buildId_not_starts_with?: Maybe<string>

    buildId_not_starts_with

  • Optional buildId_starts_with?: Maybe<string>

    buildId_starts_with

  • Optional buildUrl?: Maybe<string>

    buildUrl

  • Optional buildUrl_contains?: Maybe<string>

    buildUrl_contains

  • Optional buildUrl_ends_with?: Maybe<string>

    buildUrl_ends_with

  • Optional buildUrl_gt?: Maybe<string>

    buildUrl_gt

  • Optional buildUrl_gte?: Maybe<string>

    buildUrl_gte

  • Optional buildUrl_in?: Maybe<Array<string>>

    buildUrl_in

  • Optional buildUrl_lt?: Maybe<string>

    buildUrl_lt

  • Optional buildUrl_lte?: Maybe<string>

    buildUrl_lte

  • Optional buildUrl_not?: Maybe<string>

    buildUrl_not

  • Optional buildUrl_not_contains?: Maybe<string>

    buildUrl_not_contains

  • Optional buildUrl_not_ends_with?: Maybe<string>

    buildUrl_not_ends_with

  • Optional buildUrl_not_in?: Maybe<Array<string>>

    buildUrl_not_in

  • Optional buildUrl_not_starts_with?: Maybe<string>

    buildUrl_not_starts_with

  • Optional buildUrl_starts_with?: Maybe<string>

    buildUrl_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional compareUrl?: Maybe<string>

    compareUrl

  • Optional compareUrl_contains?: Maybe<string>

    compareUrl_contains

  • Optional compareUrl_ends_with?: Maybe<string>

    compareUrl_ends_with

  • Optional compareUrl_gt?: Maybe<string>

    compareUrl_gt

  • Optional compareUrl_gte?: Maybe<string>

    compareUrl_gte

  • Optional compareUrl_in?: Maybe<Array<string>>

    compareUrl_in

  • Optional compareUrl_lt?: Maybe<string>

    compareUrl_lt

  • Optional compareUrl_lte?: Maybe<string>

    compareUrl_lte

  • Optional compareUrl_not?: Maybe<string>

    compareUrl_not

  • Optional compareUrl_not_contains?: Maybe<string>

    compareUrl_not_contains

  • Optional compareUrl_not_ends_with?: Maybe<string>

    compareUrl_not_ends_with

  • Optional compareUrl_not_in?: Maybe<Array<string>>

    compareUrl_not_in

  • Optional compareUrl_not_starts_with?: Maybe<string>

    compareUrl_not_starts_with

  • Optional compareUrl_starts_with?: Maybe<string>

    compareUrl_starts_with

  • Optional data?: Maybe<string>

    data

  • Optional data_contains?: Maybe<string>

    data_contains

  • Optional data_ends_with?: Maybe<string>

    data_ends_with

  • Optional data_gt?: Maybe<string>

    data_gt

  • Optional data_gte?: Maybe<string>

    data_gte

  • Optional data_in?: Maybe<Array<string>>

    data_in

  • Optional data_lt?: Maybe<string>

    data_lt

  • Optional data_lte?: Maybe<string>

    data_lte

  • Optional data_not?: Maybe<string>

    data_not

  • Optional data_not_contains?: Maybe<string>

    data_not_contains

  • Optional data_not_ends_with?: Maybe<string>

    data_not_ends_with

  • Optional data_not_in?: Maybe<Array<string>>

    data_not_in

  • Optional data_not_starts_with?: Maybe<string>

    data_not_starts_with

  • Optional data_starts_with?: Maybe<string>

    data_starts_with

  • Optional finishedAt?: Maybe<string>

    finishedAt

  • Optional finishedAt_contains?: Maybe<string>

    finishedAt_contains

  • Optional finishedAt_ends_with?: Maybe<string>

    finishedAt_ends_with

  • Optional finishedAt_gt?: Maybe<string>

    finishedAt_gt

  • Optional finishedAt_gte?: Maybe<string>

    finishedAt_gte

  • Optional finishedAt_in?: Maybe<Array<string>>

    finishedAt_in

  • Optional finishedAt_lt?: Maybe<string>

    finishedAt_lt

  • Optional finishedAt_lte?: Maybe<string>

    finishedAt_lte

  • Optional finishedAt_not?: Maybe<string>

    finishedAt_not

  • Optional finishedAt_not_contains?: Maybe<string>

    finishedAt_not_contains

  • Optional finishedAt_not_ends_with?: Maybe<string>

    finishedAt_not_ends_with

  • Optional finishedAt_not_in?: Maybe<Array<string>>

    finishedAt_not_in

  • Optional finishedAt_not_starts_with?: Maybe<string>

    finishedAt_not_starts_with

  • Optional finishedAt_starts_with?: Maybe<string>

    finishedAt_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional jobId?: Maybe<string>

    jobId

  • Optional jobId_contains?: Maybe<string>

    jobId_contains

  • Optional jobId_ends_with?: Maybe<string>

    jobId_ends_with

  • Optional jobId_gt?: Maybe<string>

    jobId_gt

  • Optional jobId_gte?: Maybe<string>

    jobId_gte

  • Optional jobId_in?: Maybe<Array<string>>

    jobId_in

  • Optional jobId_lt?: Maybe<string>

    jobId_lt

  • Optional jobId_lte?: Maybe<string>

    jobId_lte

  • Optional jobId_not?: Maybe<string>

    jobId_not

  • Optional jobId_not_contains?: Maybe<string>

    jobId_not_contains

  • Optional jobId_not_ends_with?: Maybe<string>

    jobId_not_ends_with

  • Optional jobId_not_in?: Maybe<Array<string>>

    jobId_not_in

  • Optional jobId_not_starts_with?: Maybe<string>

    jobId_not_starts_with

  • Optional jobId_starts_with?: Maybe<string>

    jobId_starts_with

  • Optional jobName?: Maybe<string>

    jobName

  • Optional jobName_contains?: Maybe<string>

    jobName_contains

  • Optional jobName_ends_with?: Maybe<string>

    jobName_ends_with

  • Optional jobName_gt?: Maybe<string>

    jobName_gt

  • Optional jobName_gte?: Maybe<string>

    jobName_gte

  • Optional jobName_in?: Maybe<Array<string>>

    jobName_in

  • Optional jobName_lt?: Maybe<string>

    jobName_lt

  • Optional jobName_lte?: Maybe<string>

    jobName_lte

  • Optional jobName_not?: Maybe<string>

    jobName_not

  • Optional jobName_not_contains?: Maybe<string>

    jobName_not_contains

  • Optional jobName_not_ends_with?: Maybe<string>

    jobName_not_ends_with

  • Optional jobName_not_in?: Maybe<Array<string>>

    jobName_not_in

  • Optional jobName_not_starts_with?: Maybe<string>

    jobName_not_starts_with

  • Optional jobName_starts_with?: Maybe<string>

    jobName_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional number?: Maybe<number>

    number

  • Optional number_gt?: Maybe<number>

    number_gt

  • Optional number_gte?: Maybe<number>

    number_gte

  • Optional number_in?: Maybe<Array<number>>

    number_in

  • Optional number_lt?: Maybe<number>

    number_lt

  • Optional number_lte?: Maybe<number>

    number_lte

  • Optional number_not?: Maybe<number>

    number_not

  • Optional number_not_in?: Maybe<Array<number>>

    number_not_in

  • Optional provider?: Maybe<string>

    provider

  • Optional provider_contains?: Maybe<string>

    provider_contains

  • Optional provider_ends_with?: Maybe<string>

    provider_ends_with

  • Optional provider_gt?: Maybe<string>

    provider_gt

  • Optional provider_gte?: Maybe<string>

    provider_gte

  • Optional provider_in?: Maybe<Array<string>>

    provider_in

  • Optional provider_lt?: Maybe<string>

    provider_lt

  • Optional provider_lte?: Maybe<string>

    provider_lte

  • Optional provider_not?: Maybe<string>

    provider_not

  • Optional provider_not_contains?: Maybe<string>

    provider_not_contains

  • Optional provider_not_ends_with?: Maybe<string>

    provider_not_ends_with

  • Optional provider_not_in?: Maybe<Array<string>>

    provider_not_in

  • Optional provider_not_starts_with?: Maybe<string>

    provider_not_starts_with

  • Optional provider_starts_with?: Maybe<string>

    provider_starts_with

  • Optional pullRequest?: Maybe<_PullRequestFilter>

    pullRequest

  • Optional pullRequestNumber?: Maybe<number>

    pullRequestNumber

  • Optional pullRequestNumber_gt?: Maybe<number>

    pullRequestNumber_gt

  • Optional pullRequestNumber_gte?: Maybe<number>

    pullRequestNumber_gte

  • Optional pullRequestNumber_in?: Maybe<Array<number>>

    pullRequestNumber_in

  • Optional pullRequestNumber_lt?: Maybe<number>

    pullRequestNumber_lt

  • Optional pullRequestNumber_lte?: Maybe<number>

    pullRequestNumber_lte

  • Optional pullRequestNumber_not?: Maybe<number>

    pullRequestNumber_not

  • Optional pullRequestNumber_not_in?: Maybe<Array<number>>

    pullRequestNumber_not_in

  • Optional pullRequest_in?: Maybe<_PullRequestFilter>

    pullRequest_in

  • Optional pullRequest_not?: Maybe<_PullRequestFilter>

    pullRequest_not

  • Optional pullRequest_not_in?: Maybe<_PullRequestFilter>

    pullRequest_not_in

  • Optional push?: Maybe<_PushFilter>

    push

  • Optional push_in?: Maybe<_PushFilter>

    push_in

  • Optional push_not?: Maybe<_PushFilter>

    push_not

  • Optional push_not_in?: Maybe<_PushFilter>

    push_not_in

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional startedAt?: Maybe<string>

    startedAt

  • Optional startedAt_contains?: Maybe<string>

    startedAt_contains

  • Optional startedAt_ends_with?: Maybe<string>

    startedAt_ends_with

  • Optional startedAt_gt?: Maybe<string>

    startedAt_gt

  • Optional startedAt_gte?: Maybe<string>

    startedAt_gte

  • Optional startedAt_in?: Maybe<Array<string>>

    startedAt_in

  • Optional startedAt_lt?: Maybe<string>

    startedAt_lt

  • Optional startedAt_lte?: Maybe<string>

    startedAt_lte

  • Optional startedAt_not?: Maybe<string>

    startedAt_not

  • Optional startedAt_not_contains?: Maybe<string>

    startedAt_not_contains

  • Optional startedAt_not_ends_with?: Maybe<string>

    startedAt_not_ends_with

  • Optional startedAt_not_in?: Maybe<Array<string>>

    startedAt_not_in

  • Optional startedAt_not_starts_with?: Maybe<string>

    startedAt_not_starts_with

  • Optional startedAt_starts_with?: Maybe<string>

    startedAt_starts_with

  • Optional status?: Maybe<BuildStatus>

    status

  • Optional status_in?: Maybe<Array<BuildStatus>>

    status_in

  • Optional status_not?: Maybe<BuildStatus>

    status_not

  • Optional status_not_in?: Maybe<Array<BuildStatus>>

    status_not_in

  • Optional tag?: Maybe<_TagFilter>

    tag

  • Optional tag_in?: Maybe<_TagFilter>

    tag_in

  • Optional tag_not?: Maybe<_TagFilter>

    tag_not

  • Optional tag_not_in?: Maybe<_TagFilter>

    tag_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

  • Optional trigger?: Maybe<BuildTrigger>

    trigger

  • Optional trigger_in?: Maybe<Array<BuildTrigger>>

    trigger_in

  • Optional trigger_not?: Maybe<BuildTrigger>

    trigger_not

  • Optional trigger_not_in?: Maybe<Array<BuildTrigger>>

    trigger_not_in

  • Optional workflow?: Maybe<_WorkflowFilter>

    workflow

  • Optional workflowId?: Maybe<string>

    workflowId

  • Optional workflowId_contains?: Maybe<string>

    workflowId_contains

  • Optional workflowId_ends_with?: Maybe<string>

    workflowId_ends_with

  • Optional workflowId_gt?: Maybe<string>

    workflowId_gt

  • Optional workflowId_gte?: Maybe<string>

    workflowId_gte

  • Optional workflowId_in?: Maybe<Array<string>>

    workflowId_in

  • Optional workflowId_lt?: Maybe<string>

    workflowId_lt

  • Optional workflowId_lte?: Maybe<string>

    workflowId_lte

  • Optional workflowId_not?: Maybe<string>

    workflowId_not

  • Optional workflowId_not_contains?: Maybe<string>

    workflowId_not_contains

  • Optional workflowId_not_ends_with?: Maybe<string>

    workflowId_not_ends_with

  • Optional workflowId_not_in?: Maybe<Array<string>>

    workflowId_not_in

  • Optional workflowId_not_starts_with?: Maybe<string>

    workflowId_not_starts_with

  • Optional workflowId_starts_with?: Maybe<string>

    workflowId_starts_with

  • Optional workflow_in?: Maybe<_WorkflowFilter>

    workflow_in

  • Optional workflow_not?: Maybe<_WorkflowFilter>

    workflow_not

  • Optional workflow_not_in?: Maybe<_WorkflowFilter>

    workflow_not_in

_ChannelLinkFilter

_ChannelLinkFilter: object

Filter Input Type for ChannelLink

Type declaration

  • Optional AND?: Maybe<Array<_ChannelLinkFilter>>

    AND

  • Optional OR?: Maybe<Array<_ChannelLinkFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional channel?: Maybe<_ChatChannelFilter>

    channel

  • Optional channel_in?: Maybe<_ChatChannelFilter>

    channel_in

  • Optional channel_not?: Maybe<_ChatChannelFilter>

    channel_not

  • Optional channel_not_in?: Maybe<_ChatChannelFilter>

    channel_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

_ChatChannelFilter

_ChatChannelFilter: object

Filter Input Type for ChatChannel

Type declaration

  • Optional AND?: Maybe<Array<_ChatChannelFilter>>

    AND

  • Optional OR?: Maybe<Array<_ChatChannelFilter>>

    OR

  • Optional archived?: Maybe<boolean>

    archived

  • Optional archived_not?: Maybe<boolean>

    archived_not

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional botInvitedSelf?: Maybe<boolean>

    botInvitedSelf

  • Optional botInvitedSelf_not?: Maybe<boolean>

    botInvitedSelf_not

  • Optional channelId?: Maybe<string>

    channelId

  • Optional channelId_contains?: Maybe<string>

    channelId_contains

  • Optional channelId_ends_with?: Maybe<string>

    channelId_ends_with

  • Optional channelId_gt?: Maybe<string>

    channelId_gt

  • Optional channelId_gte?: Maybe<string>

    channelId_gte

  • Optional channelId_in?: Maybe<Array<string>>

    channelId_in

  • Optional channelId_lt?: Maybe<string>

    channelId_lt

  • Optional channelId_lte?: Maybe<string>

    channelId_lte

  • Optional channelId_not?: Maybe<string>

    channelId_not

  • Optional channelId_not_contains?: Maybe<string>

    channelId_not_contains

  • Optional channelId_not_ends_with?: Maybe<string>

    channelId_not_ends_with

  • Optional channelId_not_in?: Maybe<Array<string>>

    channelId_not_in

  • Optional channelId_not_starts_with?: Maybe<string>

    channelId_not_starts_with

  • Optional channelId_starts_with?: Maybe<string>

    channelId_starts_with

  • Optional createdBy?: Maybe<_ChatIdFilter>

    createdBy

  • Optional createdBy_in?: Maybe<_ChatIdFilter>

    createdBy_in

  • Optional createdBy_not?: Maybe<_ChatIdFilter>

    createdBy_not

  • Optional createdBy_not_in?: Maybe<_ChatIdFilter>

    createdBy_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional isDefault?: Maybe<boolean>

    isDefault

  • Optional isDefault_not?: Maybe<boolean>

    isDefault_not

  • Optional links?: Maybe<_ChannelLinkFilter>

    links

  • Optional links_every?: Maybe<_ChannelLinkFilter>

    links_every

  • Optional links_in?: Maybe<_ChannelLinkFilter>

    links_in

  • Optional links_none?: Maybe<_ChannelLinkFilter>

    links_none

  • Optional links_not?: Maybe<_ChannelLinkFilter>

    links_not

  • Optional links_not_in?: Maybe<_ChannelLinkFilter>

    links_not_in

  • Optional links_single?: Maybe<_ChannelLinkFilter>

    links_single

  • Optional links_some?: Maybe<_ChannelLinkFilter>

    links_some

  • Optional members?: Maybe<_ChatIdFilter>

    members

  • Optional members_every?: Maybe<_ChatIdFilter>

    members_every

  • Optional members_in?: Maybe<_ChatIdFilter>

    members_in

  • Optional members_none?: Maybe<_ChatIdFilter>

    members_none

  • Optional members_not?: Maybe<_ChatIdFilter>

    members_not

  • Optional members_not_in?: Maybe<_ChatIdFilter>

    members_not_in

  • Optional members_single?: Maybe<_ChatIdFilter>

    members_single

  • Optional members_some?: Maybe<_ChatIdFilter>

    members_some

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional normalizedName?: Maybe<string>

    normalizedName

  • Optional normalizedName_contains?: Maybe<string>

    normalizedName_contains

  • Optional normalizedName_ends_with?: Maybe<string>

    normalizedName_ends_with

  • Optional normalizedName_gt?: Maybe<string>

    normalizedName_gt

  • Optional normalizedName_gte?: Maybe<string>

    normalizedName_gte

  • Optional normalizedName_in?: Maybe<Array<string>>

    normalizedName_in

  • Optional normalizedName_lt?: Maybe<string>

    normalizedName_lt

  • Optional normalizedName_lte?: Maybe<string>

    normalizedName_lte

  • Optional normalizedName_not?: Maybe<string>

    normalizedName_not

  • Optional normalizedName_not_contains?: Maybe<string>

    normalizedName_not_contains

  • Optional normalizedName_not_ends_with?: Maybe<string>

    normalizedName_not_ends_with

  • Optional normalizedName_not_in?: Maybe<Array<string>>

    normalizedName_not_in

  • Optional normalizedName_not_starts_with?: Maybe<string>

    normalizedName_not_starts_with

  • Optional normalizedName_starts_with?: Maybe<string>

    normalizedName_starts_with

  • Optional provider?: Maybe<string>

    provider

  • Optional provider_contains?: Maybe<string>

    provider_contains

  • Optional provider_ends_with?: Maybe<string>

    provider_ends_with

  • Optional provider_gt?: Maybe<string>

    provider_gt

  • Optional provider_gte?: Maybe<string>

    provider_gte

  • Optional provider_in?: Maybe<Array<string>>

    provider_in

  • Optional provider_lt?: Maybe<string>

    provider_lt

  • Optional provider_lte?: Maybe<string>

    provider_lte

  • Optional provider_not?: Maybe<string>

    provider_not

  • Optional provider_not_contains?: Maybe<string>

    provider_not_contains

  • Optional provider_not_ends_with?: Maybe<string>

    provider_not_ends_with

  • Optional provider_not_in?: Maybe<Array<string>>

    provider_not_in

  • Optional provider_not_starts_with?: Maybe<string>

    provider_not_starts_with

  • Optional provider_starts_with?: Maybe<string>

    provider_starts_with

  • Optional repos?: Maybe<_RepoFilter>

    repos

  • Optional repos_every?: Maybe<_RepoFilter>

    repos_every

  • Optional repos_in?: Maybe<_RepoFilter>

    repos_in

  • Optional repos_none?: Maybe<_RepoFilter>

    repos_none

  • Optional repos_not?: Maybe<_RepoFilter>

    repos_not

  • Optional repos_not_in?: Maybe<_RepoFilter>

    repos_not_in

  • Optional repos_single?: Maybe<_RepoFilter>

    repos_single

  • Optional repos_some?: Maybe<_RepoFilter>

    repos_some

  • Optional team?: Maybe<_ChatTeamFilter>

    team

  • Optional team_in?: Maybe<_ChatTeamFilter>

    team_in

  • Optional team_not?: Maybe<_ChatTeamFilter>

    team_not

  • Optional team_not_in?: Maybe<_ChatTeamFilter>

    team_not_in

_ChatIdFilter

_ChatIdFilter: object

Filter Input Type for ChatId

Type declaration

  • Optional AND?: Maybe<Array<_ChatIdFilter>>

    AND

  • Optional OR?: Maybe<Array<_ChatIdFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional channels?: Maybe<_ChatChannelFilter>

    channels

  • Optional channelsCreated?: Maybe<_ChatChannelFilter>

    channelsCreated

  • Optional channelsCreated_every?: Maybe<_ChatChannelFilter>

    channelsCreated_every

  • Optional channelsCreated_in?: Maybe<_ChatChannelFilter>

    channelsCreated_in

  • Optional channelsCreated_none?: Maybe<_ChatChannelFilter>

    channelsCreated_none

  • Optional channelsCreated_not?: Maybe<_ChatChannelFilter>

    channelsCreated_not

  • Optional channelsCreated_not_in?: Maybe<_ChatChannelFilter>

    channelsCreated_not_in

  • Optional channelsCreated_single?: Maybe<_ChatChannelFilter>

    channelsCreated_single

  • Optional channelsCreated_some?: Maybe<_ChatChannelFilter>

    channelsCreated_some

  • Optional channels_every?: Maybe<_ChatChannelFilter>

    channels_every

  • Optional channels_in?: Maybe<_ChatChannelFilter>

    channels_in

  • Optional channels_none?: Maybe<_ChatChannelFilter>

    channels_none

  • Optional channels_not?: Maybe<_ChatChannelFilter>

    channels_not

  • Optional channels_not_in?: Maybe<_ChatChannelFilter>

    channels_not_in

  • Optional channels_single?: Maybe<_ChatChannelFilter>

    channels_single

  • Optional channels_some?: Maybe<_ChatChannelFilter>

    channels_some

  • Optional chatTeam?: Maybe<_ChatTeamFilter>

    chatTeam

  • Optional chatTeam_in?: Maybe<_ChatTeamFilter>

    chatTeam_in

  • Optional chatTeam_not?: Maybe<_ChatTeamFilter>

    chatTeam_not

  • Optional chatTeam_not_in?: Maybe<_ChatTeamFilter>

    chatTeam_not_in

  • Optional emails?: Maybe<_EmailFilter>

    emails

  • Optional emails_every?: Maybe<_EmailFilter>

    emails_every

  • Optional emails_in?: Maybe<_EmailFilter>

    emails_in

  • Optional emails_none?: Maybe<_EmailFilter>

    emails_none

  • Optional emails_not?: Maybe<_EmailFilter>

    emails_not

  • Optional emails_not_in?: Maybe<_EmailFilter>

    emails_not_in

  • Optional emails_single?: Maybe<_EmailFilter>

    emails_single

  • Optional emails_some?: Maybe<_EmailFilter>

    emails_some

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional isAdmin?: Maybe<string>

    isAdmin

  • Optional isAdmin_contains?: Maybe<string>

    isAdmin_contains

  • Optional isAdmin_ends_with?: Maybe<string>

    isAdmin_ends_with

  • Optional isAdmin_gt?: Maybe<string>

    isAdmin_gt

  • Optional isAdmin_gte?: Maybe<string>

    isAdmin_gte

  • Optional isAdmin_in?: Maybe<Array<string>>

    isAdmin_in

  • Optional isAdmin_lt?: Maybe<string>

    isAdmin_lt

  • Optional isAdmin_lte?: Maybe<string>

    isAdmin_lte

  • Optional isAdmin_not?: Maybe<string>

    isAdmin_not

  • Optional isAdmin_not_contains?: Maybe<string>

    isAdmin_not_contains

  • Optional isAdmin_not_ends_with?: Maybe<string>

    isAdmin_not_ends_with

  • Optional isAdmin_not_in?: Maybe<Array<string>>

    isAdmin_not_in

  • Optional isAdmin_not_starts_with?: Maybe<string>

    isAdmin_not_starts_with

  • Optional isAdmin_starts_with?: Maybe<string>

    isAdmin_starts_with

  • Optional isAtomistBot?: Maybe<string>

    isAtomistBot

  • Optional isAtomistBot_contains?: Maybe<string>

    isAtomistBot_contains

  • Optional isAtomistBot_ends_with?: Maybe<string>

    isAtomistBot_ends_with

  • Optional isAtomistBot_gt?: Maybe<string>

    isAtomistBot_gt

  • Optional isAtomistBot_gte?: Maybe<string>

    isAtomistBot_gte

  • Optional isAtomistBot_in?: Maybe<Array<string>>

    isAtomistBot_in

  • Optional isAtomistBot_lt?: Maybe<string>

    isAtomistBot_lt

  • Optional isAtomistBot_lte?: Maybe<string>

    isAtomistBot_lte

  • Optional isAtomistBot_not?: Maybe<string>

    isAtomistBot_not

  • Optional isAtomistBot_not_contains?: Maybe<string>

    isAtomistBot_not_contains

  • Optional isAtomistBot_not_ends_with?: Maybe<string>

    isAtomistBot_not_ends_with

  • Optional isAtomistBot_not_in?: Maybe<Array<string>>

    isAtomistBot_not_in

  • Optional isAtomistBot_not_starts_with?: Maybe<string>

    isAtomistBot_not_starts_with

  • Optional isAtomistBot_starts_with?: Maybe<string>

    isAtomistBot_starts_with

  • Optional isBot?: Maybe<string>

    isBot

  • Optional isBot_contains?: Maybe<string>

    isBot_contains

  • Optional isBot_ends_with?: Maybe<string>

    isBot_ends_with

  • Optional isBot_gt?: Maybe<string>

    isBot_gt

  • Optional isBot_gte?: Maybe<string>

    isBot_gte

  • Optional isBot_in?: Maybe<Array<string>>

    isBot_in

  • Optional isBot_lt?: Maybe<string>

    isBot_lt

  • Optional isBot_lte?: Maybe<string>

    isBot_lte

  • Optional isBot_not?: Maybe<string>

    isBot_not

  • Optional isBot_not_contains?: Maybe<string>

    isBot_not_contains

  • Optional isBot_not_ends_with?: Maybe<string>

    isBot_not_ends_with

  • Optional isBot_not_in?: Maybe<Array<string>>

    isBot_not_in

  • Optional isBot_not_starts_with?: Maybe<string>

    isBot_not_starts_with

  • Optional isBot_starts_with?: Maybe<string>

    isBot_starts_with

  • Optional isOwner?: Maybe<string>

    isOwner

  • Optional isOwner_contains?: Maybe<string>

    isOwner_contains

  • Optional isOwner_ends_with?: Maybe<string>

    isOwner_ends_with

  • Optional isOwner_gt?: Maybe<string>

    isOwner_gt

  • Optional isOwner_gte?: Maybe<string>

    isOwner_gte

  • Optional isOwner_in?: Maybe<Array<string>>

    isOwner_in

  • Optional isOwner_lt?: Maybe<string>

    isOwner_lt

  • Optional isOwner_lte?: Maybe<string>

    isOwner_lte

  • Optional isOwner_not?: Maybe<string>

    isOwner_not

  • Optional isOwner_not_contains?: Maybe<string>

    isOwner_not_contains

  • Optional isOwner_not_ends_with?: Maybe<string>

    isOwner_not_ends_with

  • Optional isOwner_not_in?: Maybe<Array<string>>

    isOwner_not_in

  • Optional isOwner_not_starts_with?: Maybe<string>

    isOwner_not_starts_with

  • Optional isOwner_starts_with?: Maybe<string>

    isOwner_starts_with

  • Optional isPrimaryOwner?: Maybe<string>

    isPrimaryOwner

  • Optional isPrimaryOwner_contains?: Maybe<string>

    isPrimaryOwner_contains

  • Optional isPrimaryOwner_ends_with?: Maybe<string>

    isPrimaryOwner_ends_with

  • Optional isPrimaryOwner_gt?: Maybe<string>

    isPrimaryOwner_gt

  • Optional isPrimaryOwner_gte?: Maybe<string>

    isPrimaryOwner_gte

  • Optional isPrimaryOwner_in?: Maybe<Array<string>>

    isPrimaryOwner_in

  • Optional isPrimaryOwner_lt?: Maybe<string>

    isPrimaryOwner_lt

  • Optional isPrimaryOwner_lte?: Maybe<string>

    isPrimaryOwner_lte

  • Optional isPrimaryOwner_not?: Maybe<string>

    isPrimaryOwner_not

  • Optional isPrimaryOwner_not_contains?: Maybe<string>

    isPrimaryOwner_not_contains

  • Optional isPrimaryOwner_not_ends_with?: Maybe<string>

    isPrimaryOwner_not_ends_with

  • Optional isPrimaryOwner_not_in?: Maybe<Array<string>>

    isPrimaryOwner_not_in

  • Optional isPrimaryOwner_not_starts_with?: Maybe<string>

    isPrimaryOwner_not_starts_with

  • Optional isPrimaryOwner_starts_with?: Maybe<string>

    isPrimaryOwner_starts_with

  • Optional person?: Maybe<_PersonFilter>

    person

  • Optional person_in?: Maybe<_PersonFilter>

    person_in

  • Optional person_not?: Maybe<_PersonFilter>

    person_not

  • Optional person_not_in?: Maybe<_PersonFilter>

    person_not_in

  • Optional provider?: Maybe<string>

    provider

  • Optional provider_contains?: Maybe<string>

    provider_contains

  • Optional provider_ends_with?: Maybe<string>

    provider_ends_with

  • Optional provider_gt?: Maybe<string>

    provider_gt

  • Optional provider_gte?: Maybe<string>

    provider_gte

  • Optional provider_in?: Maybe<Array<string>>

    provider_in

  • Optional provider_lt?: Maybe<string>

    provider_lt

  • Optional provider_lte?: Maybe<string>

    provider_lte

  • Optional provider_not?: Maybe<string>

    provider_not

  • Optional provider_not_contains?: Maybe<string>

    provider_not_contains

  • Optional provider_not_ends_with?: Maybe<string>

    provider_not_ends_with

  • Optional provider_not_in?: Maybe<Array<string>>

    provider_not_in

  • Optional provider_not_starts_with?: Maybe<string>

    provider_not_starts_with

  • Optional provider_starts_with?: Maybe<string>

    provider_starts_with

  • Optional screenName?: Maybe<string>

    screenName

  • Optional screenName_contains?: Maybe<string>

    screenName_contains

  • Optional screenName_ends_with?: Maybe<string>

    screenName_ends_with

  • Optional screenName_gt?: Maybe<string>

    screenName_gt

  • Optional screenName_gte?: Maybe<string>

    screenName_gte

  • Optional screenName_in?: Maybe<Array<string>>

    screenName_in

  • Optional screenName_lt?: Maybe<string>

    screenName_lt

  • Optional screenName_lte?: Maybe<string>

    screenName_lte

  • Optional screenName_not?: Maybe<string>

    screenName_not

  • Optional screenName_not_contains?: Maybe<string>

    screenName_not_contains

  • Optional screenName_not_ends_with?: Maybe<string>

    screenName_not_ends_with

  • Optional screenName_not_in?: Maybe<Array<string>>

    screenName_not_in

  • Optional screenName_not_starts_with?: Maybe<string>

    screenName_not_starts_with

  • Optional screenName_starts_with?: Maybe<string>

    screenName_starts_with

  • Optional timezoneLabel?: Maybe<string>

    timezoneLabel

  • Optional timezoneLabel_contains?: Maybe<string>

    timezoneLabel_contains

  • Optional timezoneLabel_ends_with?: Maybe<string>

    timezoneLabel_ends_with

  • Optional timezoneLabel_gt?: Maybe<string>

    timezoneLabel_gt

  • Optional timezoneLabel_gte?: Maybe<string>

    timezoneLabel_gte

  • Optional timezoneLabel_in?: Maybe<Array<string>>

    timezoneLabel_in

  • Optional timezoneLabel_lt?: Maybe<string>

    timezoneLabel_lt

  • Optional timezoneLabel_lte?: Maybe<string>

    timezoneLabel_lte

  • Optional timezoneLabel_not?: Maybe<string>

    timezoneLabel_not

  • Optional timezoneLabel_not_contains?: Maybe<string>

    timezoneLabel_not_contains

  • Optional timezoneLabel_not_ends_with?: Maybe<string>

    timezoneLabel_not_ends_with

  • Optional timezoneLabel_not_in?: Maybe<Array<string>>

    timezoneLabel_not_in

  • Optional timezoneLabel_not_starts_with?: Maybe<string>

    timezoneLabel_not_starts_with

  • Optional timezoneLabel_starts_with?: Maybe<string>

    timezoneLabel_starts_with

  • Optional userId?: Maybe<string>

    userId

  • Optional userId_contains?: Maybe<string>

    userId_contains

  • Optional userId_ends_with?: Maybe<string>

    userId_ends_with

  • Optional userId_gt?: Maybe<string>

    userId_gt

  • Optional userId_gte?: Maybe<string>

    userId_gte

  • Optional userId_in?: Maybe<Array<string>>

    userId_in

  • Optional userId_lt?: Maybe<string>

    userId_lt

  • Optional userId_lte?: Maybe<string>

    userId_lte

  • Optional userId_not?: Maybe<string>

    userId_not

  • Optional userId_not_contains?: Maybe<string>

    userId_not_contains

  • Optional userId_not_ends_with?: Maybe<string>

    userId_not_ends_with

  • Optional userId_not_in?: Maybe<Array<string>>

    userId_not_in

  • Optional userId_not_starts_with?: Maybe<string>

    userId_not_starts_with

  • Optional userId_starts_with?: Maybe<string>

    userId_starts_with

_ChatTeamFilter

_ChatTeamFilter: object

Filter Input Type for ChatTeam

Type declaration

  • Optional AND?: Maybe<Array<_ChatTeamFilter>>

    AND

  • Optional OR?: Maybe<Array<_ChatTeamFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional channels?: Maybe<_ChatChannelFilter>

    channels

  • Optional channels_every?: Maybe<_ChatChannelFilter>

    channels_every

  • Optional channels_in?: Maybe<_ChatChannelFilter>

    channels_in

  • Optional channels_none?: Maybe<_ChatChannelFilter>

    channels_none

  • Optional channels_not?: Maybe<_ChatChannelFilter>

    channels_not

  • Optional channels_not_in?: Maybe<_ChatChannelFilter>

    channels_not_in

  • Optional channels_single?: Maybe<_ChatChannelFilter>

    channels_single

  • Optional channels_some?: Maybe<_ChatChannelFilter>

    channels_some

  • Optional domain?: Maybe<string>

    domain

  • Optional domain_contains?: Maybe<string>

    domain_contains

  • Optional domain_ends_with?: Maybe<string>

    domain_ends_with

  • Optional domain_gt?: Maybe<string>

    domain_gt

  • Optional domain_gte?: Maybe<string>

    domain_gte

  • Optional domain_in?: Maybe<Array<string>>

    domain_in

  • Optional domain_lt?: Maybe<string>

    domain_lt

  • Optional domain_lte?: Maybe<string>

    domain_lte

  • Optional domain_not?: Maybe<string>

    domain_not

  • Optional domain_not_contains?: Maybe<string>

    domain_not_contains

  • Optional domain_not_ends_with?: Maybe<string>

    domain_not_ends_with

  • Optional domain_not_in?: Maybe<Array<string>>

    domain_not_in

  • Optional domain_not_starts_with?: Maybe<string>

    domain_not_starts_with

  • Optional domain_starts_with?: Maybe<string>

    domain_starts_with

  • Optional emailDomain?: Maybe<string>

    emailDomain

  • Optional emailDomain_contains?: Maybe<string>

    emailDomain_contains

  • Optional emailDomain_ends_with?: Maybe<string>

    emailDomain_ends_with

  • Optional emailDomain_gt?: Maybe<string>

    emailDomain_gt

  • Optional emailDomain_gte?: Maybe<string>

    emailDomain_gte

  • Optional emailDomain_in?: Maybe<Array<string>>

    emailDomain_in

  • Optional emailDomain_lt?: Maybe<string>

    emailDomain_lt

  • Optional emailDomain_lte?: Maybe<string>

    emailDomain_lte

  • Optional emailDomain_not?: Maybe<string>

    emailDomain_not

  • Optional emailDomain_not_contains?: Maybe<string>

    emailDomain_not_contains

  • Optional emailDomain_not_ends_with?: Maybe<string>

    emailDomain_not_ends_with

  • Optional emailDomain_not_in?: Maybe<Array<string>>

    emailDomain_not_in

  • Optional emailDomain_not_starts_with?: Maybe<string>

    emailDomain_not_starts_with

  • Optional emailDomain_starts_with?: Maybe<string>

    emailDomain_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional members?: Maybe<_ChatIdFilter>

    members

  • Optional members_every?: Maybe<_ChatIdFilter>

    members_every

  • Optional members_in?: Maybe<_ChatIdFilter>

    members_in

  • Optional members_none?: Maybe<_ChatIdFilter>

    members_none

  • Optional members_not?: Maybe<_ChatIdFilter>

    members_not

  • Optional members_not_in?: Maybe<_ChatIdFilter>

    members_not_in

  • Optional members_single?: Maybe<_ChatIdFilter>

    members_single

  • Optional members_some?: Maybe<_ChatIdFilter>

    members_some

  • Optional messageCount?: Maybe<number>

    messageCount

  • Optional messageCount_gt?: Maybe<number>

    messageCount_gt

  • Optional messageCount_gte?: Maybe<number>

    messageCount_gte

  • Optional messageCount_in?: Maybe<Array<number>>

    messageCount_in

  • Optional messageCount_lt?: Maybe<number>

    messageCount_lt

  • Optional messageCount_lte?: Maybe<number>

    messageCount_lte

  • Optional messageCount_not?: Maybe<number>

    messageCount_not

  • Optional messageCount_not_in?: Maybe<Array<number>>

    messageCount_not_in

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional orgs?: Maybe<_OrgFilter>

    orgs

  • Optional orgs_every?: Maybe<_OrgFilter>

    orgs_every

  • Optional orgs_in?: Maybe<_OrgFilter>

    orgs_in

  • Optional orgs_none?: Maybe<_OrgFilter>

    orgs_none

  • Optional orgs_not?: Maybe<_OrgFilter>

    orgs_not

  • Optional orgs_not_in?: Maybe<_OrgFilter>

    orgs_not_in

  • Optional orgs_single?: Maybe<_OrgFilter>

    orgs_single

  • Optional orgs_some?: Maybe<_OrgFilter>

    orgs_some

  • Optional provider?: Maybe<string>

    provider

  • Optional provider_contains?: Maybe<string>

    provider_contains

  • Optional provider_ends_with?: Maybe<string>

    provider_ends_with

  • Optional provider_gt?: Maybe<string>

    provider_gt

  • Optional provider_gte?: Maybe<string>

    provider_gte

  • Optional provider_in?: Maybe<Array<string>>

    provider_in

  • Optional provider_lt?: Maybe<string>

    provider_lt

  • Optional provider_lte?: Maybe<string>

    provider_lte

  • Optional provider_not?: Maybe<string>

    provider_not

  • Optional provider_not_contains?: Maybe<string>

    provider_not_contains

  • Optional provider_not_ends_with?: Maybe<string>

    provider_not_ends_with

  • Optional provider_not_in?: Maybe<Array<string>>

    provider_not_in

  • Optional provider_not_starts_with?: Maybe<string>

    provider_not_starts_with

  • Optional provider_starts_with?: Maybe<string>

    provider_starts_with

  • Optional providers?: Maybe<_GitHubProviderFilter>

    providers

  • Optional providers_every?: Maybe<_GitHubProviderFilter>

    providers_every

  • Optional providers_in?: Maybe<_GitHubProviderFilter>

    providers_in

  • Optional providers_none?: Maybe<_GitHubProviderFilter>

    providers_none

  • Optional providers_not?: Maybe<_GitHubProviderFilter>

    providers_not

  • Optional providers_not_in?: Maybe<_GitHubProviderFilter>

    providers_not_in

  • Optional providers_single?: Maybe<_GitHubProviderFilter>

    providers_single

  • Optional providers_some?: Maybe<_GitHubProviderFilter>

    providers_some

  • Optional scmProviders?: Maybe<_ScmProviderFilter>

    scmProviders

  • Optional scmProviders_every?: Maybe<_ScmProviderFilter>

    scmProviders_every

  • Optional scmProviders_in?: Maybe<_ScmProviderFilter>

    scmProviders_in

  • Optional scmProviders_none?: Maybe<_ScmProviderFilter>

    scmProviders_none

  • Optional scmProviders_not?: Maybe<_ScmProviderFilter>

    scmProviders_not

  • Optional scmProviders_not_in?: Maybe<_ScmProviderFilter>

    scmProviders_not_in

  • Optional scmProviders_single?: Maybe<_ScmProviderFilter>

    scmProviders_single

  • Optional scmProviders_some?: Maybe<_ScmProviderFilter>

    scmProviders_some

  • Optional team?: Maybe<_TeamFilter>

    team

  • Optional team_in?: Maybe<_TeamFilter>

    team_in

  • Optional team_not?: Maybe<_TeamFilter>

    team_not

  • Optional team_not_in?: Maybe<_TeamFilter>

    team_not_in

_CommentFilter

_CommentFilter: object

Filter Input Type for Comment

Type declaration

  • Optional AND?: Maybe<Array<_CommentFilter>>

    AND

  • Optional OR?: Maybe<Array<_CommentFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional body?: Maybe<string>

    body

  • Optional body_contains?: Maybe<string>

    body_contains

  • Optional body_ends_with?: Maybe<string>

    body_ends_with

  • Optional body_gt?: Maybe<string>

    body_gt

  • Optional body_gte?: Maybe<string>

    body_gte

  • Optional body_in?: Maybe<Array<string>>

    body_in

  • Optional body_lt?: Maybe<string>

    body_lt

  • Optional body_lte?: Maybe<string>

    body_lte

  • Optional body_not?: Maybe<string>

    body_not

  • Optional body_not_contains?: Maybe<string>

    body_not_contains

  • Optional body_not_ends_with?: Maybe<string>

    body_not_ends_with

  • Optional body_not_in?: Maybe<Array<string>>

    body_not_in

  • Optional body_not_starts_with?: Maybe<string>

    body_not_starts_with

  • Optional body_starts_with?: Maybe<string>

    body_starts_with

  • Optional by?: Maybe<_ScmIdFilter>

    by

  • Optional by_in?: Maybe<_ScmIdFilter>

    by_in

  • Optional by_not?: Maybe<_ScmIdFilter>

    by_not

  • Optional by_not_in?: Maybe<_ScmIdFilter>

    by_not_in

  • Optional commentId?: Maybe<string>

    commentId

  • Optional commentId_contains?: Maybe<string>

    commentId_contains

  • Optional commentId_ends_with?: Maybe<string>

    commentId_ends_with

  • Optional commentId_gt?: Maybe<string>

    commentId_gt

  • Optional commentId_gte?: Maybe<string>

    commentId_gte

  • Optional commentId_in?: Maybe<Array<string>>

    commentId_in

  • Optional commentId_lt?: Maybe<string>

    commentId_lt

  • Optional commentId_lte?: Maybe<string>

    commentId_lte

  • Optional commentId_not?: Maybe<string>

    commentId_not

  • Optional commentId_not_contains?: Maybe<string>

    commentId_not_contains

  • Optional commentId_not_ends_with?: Maybe<string>

    commentId_not_ends_with

  • Optional commentId_not_in?: Maybe<Array<string>>

    commentId_not_in

  • Optional commentId_not_starts_with?: Maybe<string>

    commentId_not_starts_with

  • Optional commentId_starts_with?: Maybe<string>

    commentId_starts_with

  • Optional commentType?: Maybe<CommentCommentType>

    commentType

  • Optional commentType_in?: Maybe<Array<CommentCommentType>>

    commentType_in

  • Optional commentType_not?: Maybe<CommentCommentType>

    commentType_not

  • Optional commentType_not_in?: Maybe<Array<CommentCommentType>>

    commentType_not_in

  • Optional createdAt?: Maybe<string>

    createdAt

  • Optional createdAt_contains?: Maybe<string>

    createdAt_contains

  • Optional createdAt_ends_with?: Maybe<string>

    createdAt_ends_with

  • Optional createdAt_gt?: Maybe<string>

    createdAt_gt

  • Optional createdAt_gte?: Maybe<string>

    createdAt_gte

  • Optional createdAt_in?: Maybe<Array<string>>

    createdAt_in

  • Optional createdAt_lt?: Maybe<string>

    createdAt_lt

  • Optional createdAt_lte?: Maybe<string>

    createdAt_lte

  • Optional createdAt_not?: Maybe<string>

    createdAt_not

  • Optional createdAt_not_contains?: Maybe<string>

    createdAt_not_contains

  • Optional createdAt_not_ends_with?: Maybe<string>

    createdAt_not_ends_with

  • Optional createdAt_not_in?: Maybe<Array<string>>

    createdAt_not_in

  • Optional createdAt_not_starts_with?: Maybe<string>

    createdAt_not_starts_with

  • Optional createdAt_starts_with?: Maybe<string>

    createdAt_starts_with

  • Optional gitHubId?: Maybe<string>

    gitHubId

  • Optional gitHubId_contains?: Maybe<string>

    gitHubId_contains

  • Optional gitHubId_ends_with?: Maybe<string>

    gitHubId_ends_with

  • Optional gitHubId_gt?: Maybe<string>

    gitHubId_gt

  • Optional gitHubId_gte?: Maybe<string>

    gitHubId_gte

  • Optional gitHubId_in?: Maybe<Array<string>>

    gitHubId_in

  • Optional gitHubId_lt?: Maybe<string>

    gitHubId_lt

  • Optional gitHubId_lte?: Maybe<string>

    gitHubId_lte

  • Optional gitHubId_not?: Maybe<string>

    gitHubId_not

  • Optional gitHubId_not_contains?: Maybe<string>

    gitHubId_not_contains

  • Optional gitHubId_not_ends_with?: Maybe<string>

    gitHubId_not_ends_with

  • Optional gitHubId_not_in?: Maybe<Array<string>>

    gitHubId_not_in

  • Optional gitHubId_not_starts_with?: Maybe<string>

    gitHubId_not_starts_with

  • Optional gitHubId_starts_with?: Maybe<string>

    gitHubId_starts_with

  • Optional htmlUrl?: Maybe<string>

    htmlUrl

  • Optional htmlUrl_contains?: Maybe<string>

    htmlUrl_contains

  • Optional htmlUrl_ends_with?: Maybe<string>

    htmlUrl_ends_with

  • Optional htmlUrl_gt?: Maybe<string>

    htmlUrl_gt

  • Optional htmlUrl_gte?: Maybe<string>

    htmlUrl_gte

  • Optional htmlUrl_in?: Maybe<Array<string>>

    htmlUrl_in

  • Optional htmlUrl_lt?: Maybe<string>

    htmlUrl_lt

  • Optional htmlUrl_lte?: Maybe<string>

    htmlUrl_lte

  • Optional htmlUrl_not?: Maybe<string>

    htmlUrl_not

  • Optional htmlUrl_not_contains?: Maybe<string>

    htmlUrl_not_contains

  • Optional htmlUrl_not_ends_with?: Maybe<string>

    htmlUrl_not_ends_with

  • Optional htmlUrl_not_in?: Maybe<Array<string>>

    htmlUrl_not_in

  • Optional htmlUrl_not_starts_with?: Maybe<string>

    htmlUrl_not_starts_with

  • Optional htmlUrl_starts_with?: Maybe<string>

    htmlUrl_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional issue?: Maybe<_IssueFilter>

    issue

  • Optional issue_in?: Maybe<_IssueFilter>

    issue_in

  • Optional issue_not?: Maybe<_IssueFilter>

    issue_not

  • Optional issue_not_in?: Maybe<_IssueFilter>

    issue_not_in

  • Optional path?: Maybe<string>

    path

  • Optional path_contains?: Maybe<string>

    path_contains

  • Optional path_ends_with?: Maybe<string>

    path_ends_with

  • Optional path_gt?: Maybe<string>

    path_gt

  • Optional path_gte?: Maybe<string>

    path_gte

  • Optional path_in?: Maybe<Array<string>>

    path_in

  • Optional path_lt?: Maybe<string>

    path_lt

  • Optional path_lte?: Maybe<string>

    path_lte

  • Optional path_not?: Maybe<string>

    path_not

  • Optional path_not_contains?: Maybe<string>

    path_not_contains

  • Optional path_not_ends_with?: Maybe<string>

    path_not_ends_with

  • Optional path_not_in?: Maybe<Array<string>>

    path_not_in

  • Optional path_not_starts_with?: Maybe<string>

    path_not_starts_with

  • Optional path_starts_with?: Maybe<string>

    path_starts_with

  • Optional position?: Maybe<string>

    position

  • Optional position_contains?: Maybe<string>

    position_contains

  • Optional position_ends_with?: Maybe<string>

    position_ends_with

  • Optional position_gt?: Maybe<string>

    position_gt

  • Optional position_gte?: Maybe<string>

    position_gte

  • Optional position_in?: Maybe<Array<string>>

    position_in

  • Optional position_lt?: Maybe<string>

    position_lt

  • Optional position_lte?: Maybe<string>

    position_lte

  • Optional position_not?: Maybe<string>

    position_not

  • Optional position_not_contains?: Maybe<string>

    position_not_contains

  • Optional position_not_ends_with?: Maybe<string>

    position_not_ends_with

  • Optional position_not_in?: Maybe<Array<string>>

    position_not_in

  • Optional position_not_starts_with?: Maybe<string>

    position_not_starts_with

  • Optional position_starts_with?: Maybe<string>

    position_starts_with

  • Optional pullRequest?: Maybe<_PullRequestFilter>

    pullRequest

  • Optional pullRequest_in?: Maybe<_PullRequestFilter>

    pullRequest_in

  • Optional pullRequest_not?: Maybe<_PullRequestFilter>

    pullRequest_not

  • Optional pullRequest_not_in?: Maybe<_PullRequestFilter>

    pullRequest_not_in

  • Optional review?: Maybe<_ReviewFilter>

    review

  • Optional review_in?: Maybe<_ReviewFilter>

    review_in

  • Optional review_not?: Maybe<_ReviewFilter>

    review_not

  • Optional review_not_in?: Maybe<_ReviewFilter>

    review_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

  • Optional updatedAt?: Maybe<string>

    updatedAt

  • Optional updatedAt_contains?: Maybe<string>

    updatedAt_contains

  • Optional updatedAt_ends_with?: Maybe<string>

    updatedAt_ends_with

  • Optional updatedAt_gt?: Maybe<string>

    updatedAt_gt

  • Optional updatedAt_gte?: Maybe<string>

    updatedAt_gte

  • Optional updatedAt_in?: Maybe<Array<string>>

    updatedAt_in

  • Optional updatedAt_lt?: Maybe<string>

    updatedAt_lt

  • Optional updatedAt_lte?: Maybe<string>

    updatedAt_lte

  • Optional updatedAt_not?: Maybe<string>

    updatedAt_not

  • Optional updatedAt_not_contains?: Maybe<string>

    updatedAt_not_contains

  • Optional updatedAt_not_ends_with?: Maybe<string>

    updatedAt_not_ends_with

  • Optional updatedAt_not_in?: Maybe<Array<string>>

    updatedAt_not_in

  • Optional updatedAt_not_starts_with?: Maybe<string>

    updatedAt_not_starts_with

  • Optional updatedAt_starts_with?: Maybe<string>

    updatedAt_starts_with

_CommitFilter

_CommitFilter: object

Filter Input Type for Commit

Type declaration

_DeletedBranchFilter

_DeletedBranchFilter: object

Filter Input Type for DeletedBranch

Type declaration

  • Optional AND?: Maybe<Array<_DeletedBranchFilter>>

    AND

  • Optional OR?: Maybe<Array<_DeletedBranchFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional pullRequests?: Maybe<_PullRequestFilter>

    pullRequests

  • Optional pullRequests_every?: Maybe<_PullRequestFilter>

    pullRequests_every

  • Optional pullRequests_in?: Maybe<_PullRequestFilter>

    pullRequests_in

  • Optional pullRequests_none?: Maybe<_PullRequestFilter>

    pullRequests_none

  • Optional pullRequests_not?: Maybe<_PullRequestFilter>

    pullRequests_not

  • Optional pullRequests_not_in?: Maybe<_PullRequestFilter>

    pullRequests_not_in

  • Optional pullRequests_single?: Maybe<_PullRequestFilter>

    pullRequests_single

  • Optional pullRequests_some?: Maybe<_PullRequestFilter>

    pullRequests_some

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_DockerImageFilter

_DockerImageFilter: object

Filter Input Type for DockerImage

Type declaration

  • Optional AND?: Maybe<Array<_DockerImageFilter>>

    AND

  • Optional OR?: Maybe<Array<_DockerImageFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commits?: Maybe<_CommitFilter>

    commits

  • Optional commits_every?: Maybe<_CommitFilter>

    commits_every

  • Optional commits_in?: Maybe<_CommitFilter>

    commits_in

  • Optional commits_none?: Maybe<_CommitFilter>

    commits_none

  • Optional commits_not?: Maybe<_CommitFilter>

    commits_not

  • Optional commits_not_in?: Maybe<_CommitFilter>

    commits_not_in

  • Optional commits_single?: Maybe<_CommitFilter>

    commits_single

  • Optional commits_some?: Maybe<_CommitFilter>

    commits_some

  • Optional containers?: Maybe<_K8ContainerFilter>

    containers

  • Optional containers_every?: Maybe<_K8ContainerFilter>

    containers_every

  • Optional containers_in?: Maybe<_K8ContainerFilter>

    containers_in

  • Optional containers_none?: Maybe<_K8ContainerFilter>

    containers_none

  • Optional containers_not?: Maybe<_K8ContainerFilter>

    containers_not

  • Optional containers_not_in?: Maybe<_K8ContainerFilter>

    containers_not_in

  • Optional containers_single?: Maybe<_K8ContainerFilter>

    containers_single

  • Optional containers_some?: Maybe<_K8ContainerFilter>

    containers_some

  • Optional image?: Maybe<string>

    image

  • Optional imageName?: Maybe<string>

    imageName

  • Optional imageName_contains?: Maybe<string>

    imageName_contains

  • Optional imageName_ends_with?: Maybe<string>

    imageName_ends_with

  • Optional imageName_gt?: Maybe<string>

    imageName_gt

  • Optional imageName_gte?: Maybe<string>

    imageName_gte

  • Optional imageName_in?: Maybe<Array<string>>

    imageName_in

  • Optional imageName_lt?: Maybe<string>

    imageName_lt

  • Optional imageName_lte?: Maybe<string>

    imageName_lte

  • Optional imageName_not?: Maybe<string>

    imageName_not

  • Optional imageName_not_contains?: Maybe<string>

    imageName_not_contains

  • Optional imageName_not_ends_with?: Maybe<string>

    imageName_not_ends_with

  • Optional imageName_not_in?: Maybe<Array<string>>

    imageName_not_in

  • Optional imageName_not_starts_with?: Maybe<string>

    imageName_not_starts_with

  • Optional imageName_starts_with?: Maybe<string>

    imageName_starts_with

  • Optional image_contains?: Maybe<string>

    image_contains

  • Optional image_ends_with?: Maybe<string>

    image_ends_with

  • Optional image_gt?: Maybe<string>

    image_gt

  • Optional image_gte?: Maybe<string>

    image_gte

  • Optional image_in?: Maybe<Array<string>>

    image_in

  • Optional image_lt?: Maybe<string>

    image_lt

  • Optional image_lte?: Maybe<string>

    image_lte

  • Optional image_not?: Maybe<string>

    image_not

  • Optional image_not_contains?: Maybe<string>

    image_not_contains

  • Optional image_not_ends_with?: Maybe<string>

    image_not_ends_with

  • Optional image_not_in?: Maybe<Array<string>>

    image_not_in

  • Optional image_not_starts_with?: Maybe<string>

    image_not_starts_with

  • Optional image_starts_with?: Maybe<string>

    image_starts_with

  • Optional pods?: Maybe<_K8PodFilter>

    pods

  • Optional pods_every?: Maybe<_K8PodFilter>

    pods_every

  • Optional pods_in?: Maybe<_K8PodFilter>

    pods_in

  • Optional pods_none?: Maybe<_K8PodFilter>

    pods_none

  • Optional pods_not?: Maybe<_K8PodFilter>

    pods_not

  • Optional pods_not_in?: Maybe<_K8PodFilter>

    pods_not_in

  • Optional pods_single?: Maybe<_K8PodFilter>

    pods_single

  • Optional pods_some?: Maybe<_K8PodFilter>

    pods_some

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_EmailFilter

_EmailFilter: object

Filter Input Type for Email

Type declaration

  • Optional AND?: Maybe<Array<_EmailFilter>>

    AND

  • Optional OR?: Maybe<Array<_EmailFilter>>

    OR

  • Optional address?: Maybe<string>

    address

  • Optional address_contains?: Maybe<string>

    address_contains

  • Optional address_ends_with?: Maybe<string>

    address_ends_with

  • Optional address_gt?: Maybe<string>

    address_gt

  • Optional address_gte?: Maybe<string>

    address_gte

  • Optional address_in?: Maybe<Array<string>>

    address_in

  • Optional address_lt?: Maybe<string>

    address_lt

  • Optional address_lte?: Maybe<string>

    address_lte

  • Optional address_not?: Maybe<string>

    address_not

  • Optional address_not_contains?: Maybe<string>

    address_not_contains

  • Optional address_not_ends_with?: Maybe<string>

    address_not_ends_with

  • Optional address_not_in?: Maybe<Array<string>>

    address_not_in

  • Optional address_not_starts_with?: Maybe<string>

    address_not_starts_with

  • Optional address_starts_with?: Maybe<string>

    address_starts_with

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional chatId?: Maybe<_ChatIdFilter>

    chatId

  • Optional chatId_in?: Maybe<_ChatIdFilter>

    chatId_in

  • Optional chatId_not?: Maybe<_ChatIdFilter>

    chatId_not

  • Optional chatId_not_in?: Maybe<_ChatIdFilter>

    chatId_not_in

  • Optional gitHubId?: Maybe<_GitHubIdFilter>

    gitHubId

  • Optional gitHubId_in?: Maybe<_GitHubIdFilter>

    gitHubId_in

  • Optional gitHubId_not?: Maybe<_GitHubIdFilter>

    gitHubId_not

  • Optional gitHubId_not_in?: Maybe<_GitHubIdFilter>

    gitHubId_not_in

  • Optional person?: Maybe<_PersonFilter>

    person

  • Optional person_in?: Maybe<_PersonFilter>

    person_in

  • Optional person_not?: Maybe<_PersonFilter>

    person_not

  • Optional person_not_in?: Maybe<_PersonFilter>

    person_not_in

  • Optional scmId?: Maybe<_ScmIdFilter>

    scmId

  • Optional scmId_in?: Maybe<_ScmIdFilter>

    scmId_in

  • Optional scmId_not?: Maybe<_ScmIdFilter>

    scmId_not

  • Optional scmId_not_in?: Maybe<_ScmIdFilter>

    scmId_not_in

_FingerprintFilter

_FingerprintFilter: object

Filter Input Type for Fingerprint

Type declaration

  • Optional AND?: Maybe<Array<_FingerprintFilter>>

    AND

  • Optional OR?: Maybe<Array<_FingerprintFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional data?: Maybe<string>

    data

  • Optional data_contains?: Maybe<string>

    data_contains

  • Optional data_ends_with?: Maybe<string>

    data_ends_with

  • Optional data_gt?: Maybe<string>

    data_gt

  • Optional data_gte?: Maybe<string>

    data_gte

  • Optional data_in?: Maybe<Array<string>>

    data_in

  • Optional data_lt?: Maybe<string>

    data_lt

  • Optional data_lte?: Maybe<string>

    data_lte

  • Optional data_not?: Maybe<string>

    data_not

  • Optional data_not_contains?: Maybe<string>

    data_not_contains

  • Optional data_not_ends_with?: Maybe<string>

    data_not_ends_with

  • Optional data_not_in?: Maybe<Array<string>>

    data_not_in

  • Optional data_not_starts_with?: Maybe<string>

    data_not_starts_with

  • Optional data_starts_with?: Maybe<string>

    data_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional sha?: Maybe<string>

    sha

  • Optional sha_contains?: Maybe<string>

    sha_contains

  • Optional sha_ends_with?: Maybe<string>

    sha_ends_with

  • Optional sha_gt?: Maybe<string>

    sha_gt

  • Optional sha_gte?: Maybe<string>

    sha_gte

  • Optional sha_in?: Maybe<Array<string>>

    sha_in

  • Optional sha_lt?: Maybe<string>

    sha_lt

  • Optional sha_lte?: Maybe<string>

    sha_lte

  • Optional sha_not?: Maybe<string>

    sha_not

  • Optional sha_not_contains?: Maybe<string>

    sha_not_contains

  • Optional sha_not_ends_with?: Maybe<string>

    sha_not_ends_with

  • Optional sha_not_in?: Maybe<Array<string>>

    sha_not_in

  • Optional sha_not_starts_with?: Maybe<string>

    sha_not_starts_with

  • Optional sha_starts_with?: Maybe<string>

    sha_starts_with

_GitHubIdFilter

_GitHubIdFilter: object

Filter Input Type for GitHubId

Type declaration

  • Optional AND?: Maybe<Array<_GitHubIdFilter>>

    AND

  • Optional OR?: Maybe<Array<_GitHubIdFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional emails?: Maybe<_EmailFilter>

    emails

  • Optional emails_every?: Maybe<_EmailFilter>

    emails_every

  • Optional emails_in?: Maybe<_EmailFilter>

    emails_in

  • Optional emails_none?: Maybe<_EmailFilter>

    emails_none

  • Optional emails_not?: Maybe<_EmailFilter>

    emails_not

  • Optional emails_not_in?: Maybe<_EmailFilter>

    emails_not_in

  • Optional emails_single?: Maybe<_EmailFilter>

    emails_single

  • Optional emails_some?: Maybe<_EmailFilter>

    emails_some

  • Optional login?: Maybe<string>

    login

  • Optional login_contains?: Maybe<string>

    login_contains

  • Optional login_ends_with?: Maybe<string>

    login_ends_with

  • Optional login_gt?: Maybe<string>

    login_gt

  • Optional login_gte?: Maybe<string>

    login_gte

  • Optional login_in?: Maybe<Array<string>>

    login_in

  • Optional login_lt?: Maybe<string>

    login_lt

  • Optional login_lte?: Maybe<string>

    login_lte

  • Optional login_not?: Maybe<string>

    login_not

  • Optional login_not_contains?: Maybe<string>

    login_not_contains

  • Optional login_not_ends_with?: Maybe<string>

    login_not_ends_with

  • Optional login_not_in?: Maybe<Array<string>>

    login_not_in

  • Optional login_not_starts_with?: Maybe<string>

    login_not_starts_with

  • Optional login_starts_with?: Maybe<string>

    login_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional person?: Maybe<_PersonFilter>

    person

  • Optional person_in?: Maybe<_PersonFilter>

    person_in

  • Optional person_not?: Maybe<_PersonFilter>

    person_not

  • Optional person_not_in?: Maybe<_PersonFilter>

    person_not_in

  • Optional provider?: Maybe<_GitHubProviderFilter>

    provider

  • Optional provider_every?: Maybe<_GitHubProviderFilter>

    provider_every

  • Optional provider_in?: Maybe<_GitHubProviderFilter>

    provider_in

  • Optional provider_none?: Maybe<_GitHubProviderFilter>

    provider_none

  • Optional provider_not?: Maybe<_GitHubProviderFilter>

    provider_not

  • Optional provider_not_in?: Maybe<_GitHubProviderFilter>

    provider_not_in

  • Optional provider_single?: Maybe<_GitHubProviderFilter>

    provider_single

  • Optional provider_some?: Maybe<_GitHubProviderFilter>

    provider_some

  • Optional scmProvider?: Maybe<_ScmProviderFilter>

    scmProvider

  • Optional scmProvider_in?: Maybe<_ScmProviderFilter>

    scmProvider_in

  • Optional scmProvider_not?: Maybe<_ScmProviderFilter>

    scmProvider_not

  • Optional scmProvider_not_in?: Maybe<_ScmProviderFilter>

    scmProvider_not_in

_GitHubOrgWebhookFilter

_GitHubOrgWebhookFilter: object

Filter Input Type for GitHubOrgWebhook

Type declaration

  • Optional AND?: Maybe<Array<_GitHubOrgWebhookFilter>>

    AND

  • Optional OR?: Maybe<Array<_GitHubOrgWebhookFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional org?: Maybe<_OrgFilter>

    org

  • Optional org_in?: Maybe<_OrgFilter>

    org_in

  • Optional org_not?: Maybe<_OrgFilter>

    org_not

  • Optional org_not_in?: Maybe<_OrgFilter>

    org_not_in

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

  • Optional webhookType?: Maybe<WebhookType>

    webhookType

  • Optional webhookType_in?: Maybe<Array<WebhookType>>

    webhookType_in

  • Optional webhookType_not?: Maybe<WebhookType>

    webhookType_not

  • Optional webhookType_not_in?: Maybe<Array<WebhookType>>

    webhookType_not_in

_GitHubProviderFilter

_GitHubProviderFilter: object

Filter Input Type for GitHubProvider

Type declaration

  • Optional AND?: Maybe<Array<_GitHubProviderFilter>>

    AND

  • Optional OR?: Maybe<Array<_GitHubProviderFilter>>

    OR

  • Optional apiUrl?: Maybe<string>

    apiUrl

  • Optional apiUrl_contains?: Maybe<string>

    apiUrl_contains

  • Optional apiUrl_ends_with?: Maybe<string>

    apiUrl_ends_with

  • Optional apiUrl_gt?: Maybe<string>

    apiUrl_gt

  • Optional apiUrl_gte?: Maybe<string>

    apiUrl_gte

  • Optional apiUrl_in?: Maybe<Array<string>>

    apiUrl_in

  • Optional apiUrl_lt?: Maybe<string>

    apiUrl_lt

  • Optional apiUrl_lte?: Maybe<string>

    apiUrl_lte

  • Optional apiUrl_not?: Maybe<string>

    apiUrl_not

  • Optional apiUrl_not_contains?: Maybe<string>

    apiUrl_not_contains

  • Optional apiUrl_not_ends_with?: Maybe<string>

    apiUrl_not_ends_with

  • Optional apiUrl_not_in?: Maybe<Array<string>>

    apiUrl_not_in

  • Optional apiUrl_not_starts_with?: Maybe<string>

    apiUrl_not_starts_with

  • Optional apiUrl_starts_with?: Maybe<string>

    apiUrl_starts_with

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional gitUrl?: Maybe<string>

    gitUrl

  • Optional gitUrl_contains?: Maybe<string>

    gitUrl_contains

  • Optional gitUrl_ends_with?: Maybe<string>

    gitUrl_ends_with

  • Optional gitUrl_gt?: Maybe<string>

    gitUrl_gt

  • Optional gitUrl_gte?: Maybe<string>

    gitUrl_gte

  • Optional gitUrl_in?: Maybe<Array<string>>

    gitUrl_in

  • Optional gitUrl_lt?: Maybe<string>

    gitUrl_lt

  • Optional gitUrl_lte?: Maybe<string>

    gitUrl_lte

  • Optional gitUrl_not?: Maybe<string>

    gitUrl_not

  • Optional gitUrl_not_contains?: Maybe<string>

    gitUrl_not_contains

  • Optional gitUrl_not_ends_with?: Maybe<string>

    gitUrl_not_ends_with

  • Optional gitUrl_not_in?: Maybe<Array<string>>

    gitUrl_not_in

  • Optional gitUrl_not_starts_with?: Maybe<string>

    gitUrl_not_starts_with

  • Optional gitUrl_starts_with?: Maybe<string>

    gitUrl_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional private?: Maybe<boolean>

    private

  • Optional private_not?: Maybe<boolean>

    private_not

  • Optional providerId?: Maybe<string>

    providerId

  • Optional providerId_contains?: Maybe<string>

    providerId_contains

  • Optional providerId_ends_with?: Maybe<string>

    providerId_ends_with

  • Optional providerId_gt?: Maybe<string>

    providerId_gt

  • Optional providerId_gte?: Maybe<string>

    providerId_gte

  • Optional providerId_in?: Maybe<Array<string>>

    providerId_in

  • Optional providerId_lt?: Maybe<string>

    providerId_lt

  • Optional providerId_lte?: Maybe<string>

    providerId_lte

  • Optional providerId_not?: Maybe<string>

    providerId_not

  • Optional providerId_not_contains?: Maybe<string>

    providerId_not_contains

  • Optional providerId_not_ends_with?: Maybe<string>

    providerId_not_ends_with

  • Optional providerId_not_in?: Maybe<Array<string>>

    providerId_not_in

  • Optional providerId_not_starts_with?: Maybe<string>

    providerId_not_starts_with

  • Optional providerId_starts_with?: Maybe<string>

    providerId_starts_with

  • Optional providerType?: Maybe<ProviderType>

    providerType

  • Optional providerType_in?: Maybe<Array<ProviderType>>

    providerType_in

  • Optional providerType_not?: Maybe<ProviderType>

    providerType_not

  • Optional providerType_not_in?: Maybe<Array<ProviderType>>

    providerType_not_in

  • Optional team?: Maybe<_TeamFilter>

    team

  • Optional team_in?: Maybe<_TeamFilter>

    team_in

  • Optional team_not?: Maybe<_TeamFilter>

    team_not

  • Optional team_not_in?: Maybe<_TeamFilter>

    team_not_in

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

_HerokuAppFilter

_HerokuAppFilter: object

Filter Input Type for HerokuApp

Type declaration

  • Optional AND?: Maybe<Array<_HerokuAppFilter>>

    AND

  • Optional OR?: Maybe<Array<_HerokuAppFilter>>

    OR

  • Optional app?: Maybe<string>

    app

  • Optional appId?: Maybe<string>

    appId

  • Optional appId_contains?: Maybe<string>

    appId_contains

  • Optional appId_ends_with?: Maybe<string>

    appId_ends_with

  • Optional appId_gt?: Maybe<string>

    appId_gt

  • Optional appId_gte?: Maybe<string>

    appId_gte

  • Optional appId_in?: Maybe<Array<string>>

    appId_in

  • Optional appId_lt?: Maybe<string>

    appId_lt

  • Optional appId_lte?: Maybe<string>

    appId_lte

  • Optional appId_not?: Maybe<string>

    appId_not

  • Optional appId_not_contains?: Maybe<string>

    appId_not_contains

  • Optional appId_not_ends_with?: Maybe<string>

    appId_not_ends_with

  • Optional appId_not_in?: Maybe<Array<string>>

    appId_not_in

  • Optional appId_not_starts_with?: Maybe<string>

    appId_not_starts_with

  • Optional appId_starts_with?: Maybe<string>

    appId_starts_with

  • Optional app_contains?: Maybe<string>

    app_contains

  • Optional app_ends_with?: Maybe<string>

    app_ends_with

  • Optional app_gt?: Maybe<string>

    app_gt

  • Optional app_gte?: Maybe<string>

    app_gte

  • Optional app_in?: Maybe<Array<string>>

    app_in

  • Optional app_lt?: Maybe<string>

    app_lt

  • Optional app_lte?: Maybe<string>

    app_lte

  • Optional app_not?: Maybe<string>

    app_not

  • Optional app_not_contains?: Maybe<string>

    app_not_contains

  • Optional app_not_ends_with?: Maybe<string>

    app_not_ends_with

  • Optional app_not_in?: Maybe<Array<string>>

    app_not_in

  • Optional app_not_starts_with?: Maybe<string>

    app_not_starts_with

  • Optional app_starts_with?: Maybe<string>

    app_starts_with

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commits?: Maybe<_CommitFilter>

    commits

  • Optional commits_every?: Maybe<_CommitFilter>

    commits_every

  • Optional commits_in?: Maybe<_CommitFilter>

    commits_in

  • Optional commits_none?: Maybe<_CommitFilter>

    commits_none

  • Optional commits_not?: Maybe<_CommitFilter>

    commits_not

  • Optional commits_not_in?: Maybe<_CommitFilter>

    commits_not_in

  • Optional commits_single?: Maybe<_CommitFilter>

    commits_single

  • Optional commits_some?: Maybe<_CommitFilter>

    commits_some

  • Optional release?: Maybe<string>

    release

  • Optional release_contains?: Maybe<string>

    release_contains

  • Optional release_ends_with?: Maybe<string>

    release_ends_with

  • Optional release_gt?: Maybe<string>

    release_gt

  • Optional release_gte?: Maybe<string>

    release_gte

  • Optional release_in?: Maybe<Array<string>>

    release_in

  • Optional release_lt?: Maybe<string>

    release_lt

  • Optional release_lte?: Maybe<string>

    release_lte

  • Optional release_not?: Maybe<string>

    release_not

  • Optional release_not_contains?: Maybe<string>

    release_not_contains

  • Optional release_not_ends_with?: Maybe<string>

    release_not_ends_with

  • Optional release_not_in?: Maybe<Array<string>>

    release_not_in

  • Optional release_not_starts_with?: Maybe<string>

    release_not_starts_with

  • Optional release_starts_with?: Maybe<string>

    release_starts_with

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

  • Optional user?: Maybe<string>

    user

  • Optional user_contains?: Maybe<string>

    user_contains

  • Optional user_ends_with?: Maybe<string>

    user_ends_with

  • Optional user_gt?: Maybe<string>

    user_gt

  • Optional user_gte?: Maybe<string>

    user_gte

  • Optional user_in?: Maybe<Array<string>>

    user_in

  • Optional user_lt?: Maybe<string>

    user_lt

  • Optional user_lte?: Maybe<string>

    user_lte

  • Optional user_not?: Maybe<string>

    user_not

  • Optional user_not_contains?: Maybe<string>

    user_not_contains

  • Optional user_not_ends_with?: Maybe<string>

    user_not_ends_with

  • Optional user_not_in?: Maybe<Array<string>>

    user_not_in

  • Optional user_not_starts_with?: Maybe<string>

    user_not_starts_with

  • Optional user_starts_with?: Maybe<string>

    user_starts_with

_ImageLinkedFilter

_ImageLinkedFilter: object

Filter Input Type for ImageLinked

Type declaration

  • Optional AND?: Maybe<Array<_ImageLinkedFilter>>

    AND

  • Optional OR?: Maybe<Array<_ImageLinkedFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional image?: Maybe<_DockerImageFilter>

    image

  • Optional image_in?: Maybe<_DockerImageFilter>

    image_in

  • Optional image_not?: Maybe<_DockerImageFilter>

    image_not

  • Optional image_not_in?: Maybe<_DockerImageFilter>

    image_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_IssueFilter

_IssueFilter: object

Filter Input Type for Issue

Type declaration

  • Optional AND?: Maybe<Array<_IssueFilter>>

    AND

  • Optional OR?: Maybe<Array<_IssueFilter>>

    OR

  • Optional action?: Maybe<string>

    action

  • Optional action_contains?: Maybe<string>

    action_contains

  • Optional action_ends_with?: Maybe<string>

    action_ends_with

  • Optional action_gt?: Maybe<string>

    action_gt

  • Optional action_gte?: Maybe<string>

    action_gte

  • Optional action_in?: Maybe<Array<string>>

    action_in

  • Optional action_lt?: Maybe<string>

    action_lt

  • Optional action_lte?: Maybe<string>

    action_lte

  • Optional action_not?: Maybe<string>

    action_not

  • Optional action_not_contains?: Maybe<string>

    action_not_contains

  • Optional action_not_ends_with?: Maybe<string>

    action_not_ends_with

  • Optional action_not_in?: Maybe<Array<string>>

    action_not_in

  • Optional action_not_starts_with?: Maybe<string>

    action_not_starts_with

  • Optional action_starts_with?: Maybe<string>

    action_starts_with

  • Optional assignees?: Maybe<_ScmIdFilter>

    assignees

  • Optional assignees_every?: Maybe<_ScmIdFilter>

    assignees_every

  • Optional assignees_in?: Maybe<_ScmIdFilter>

    assignees_in

  • Optional assignees_none?: Maybe<_ScmIdFilter>

    assignees_none

  • Optional assignees_not?: Maybe<_ScmIdFilter>

    assignees_not

  • Optional assignees_not_in?: Maybe<_ScmIdFilter>

    assignees_not_in

  • Optional assignees_single?: Maybe<_ScmIdFilter>

    assignees_single

  • Optional assignees_some?: Maybe<_ScmIdFilter>

    assignees_some

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional body?: Maybe<string>

    body

  • Optional body_contains?: Maybe<string>

    body_contains

  • Optional body_ends_with?: Maybe<string>

    body_ends_with

  • Optional body_gt?: Maybe<string>

    body_gt

  • Optional body_gte?: Maybe<string>

    body_gte

  • Optional body_in?: Maybe<Array<string>>

    body_in

  • Optional body_lt?: Maybe<string>

    body_lt

  • Optional body_lte?: Maybe<string>

    body_lte

  • Optional body_not?: Maybe<string>

    body_not

  • Optional body_not_contains?: Maybe<string>

    body_not_contains

  • Optional body_not_ends_with?: Maybe<string>

    body_not_ends_with

  • Optional body_not_in?: Maybe<Array<string>>

    body_not_in

  • Optional body_not_starts_with?: Maybe<string>

    body_not_starts_with

  • Optional body_starts_with?: Maybe<string>

    body_starts_with

  • Optional closedAt?: Maybe<string>

    closedAt

  • Optional closedAt_contains?: Maybe<string>

    closedAt_contains

  • Optional closedAt_ends_with?: Maybe<string>

    closedAt_ends_with

  • Optional closedAt_gt?: Maybe<string>

    closedAt_gt

  • Optional closedAt_gte?: Maybe<string>

    closedAt_gte

  • Optional closedAt_in?: Maybe<Array<string>>

    closedAt_in

  • Optional closedAt_lt?: Maybe<string>

    closedAt_lt

  • Optional closedAt_lte?: Maybe<string>

    closedAt_lte

  • Optional closedAt_not?: Maybe<string>

    closedAt_not

  • Optional closedAt_not_contains?: Maybe<string>

    closedAt_not_contains

  • Optional closedAt_not_ends_with?: Maybe<string>

    closedAt_not_ends_with

  • Optional closedAt_not_in?: Maybe<Array<string>>

    closedAt_not_in

  • Optional closedAt_not_starts_with?: Maybe<string>

    closedAt_not_starts_with

  • Optional closedAt_starts_with?: Maybe<string>

    closedAt_starts_with

  • Optional closedBy?: Maybe<_ScmIdFilter>

    closedBy

  • Optional closedBy_in?: Maybe<_ScmIdFilter>

    closedBy_in

  • Optional closedBy_not?: Maybe<_ScmIdFilter>

    closedBy_not

  • Optional closedBy_not_in?: Maybe<_ScmIdFilter>

    closedBy_not_in

  • Optional comments?: Maybe<_CommentFilter>

    comments

  • Optional comments_every?: Maybe<_CommentFilter>

    comments_every

  • Optional comments_in?: Maybe<_CommentFilter>

    comments_in

  • Optional comments_none?: Maybe<_CommentFilter>

    comments_none

  • Optional comments_not?: Maybe<_CommentFilter>

    comments_not

  • Optional comments_not_in?: Maybe<_CommentFilter>

    comments_not_in

  • Optional comments_single?: Maybe<_CommentFilter>

    comments_single

  • Optional comments_some?: Maybe<_CommentFilter>

    comments_some

  • Optional createdAt?: Maybe<string>

    createdAt

  • Optional createdAt_contains?: Maybe<string>

    createdAt_contains

  • Optional createdAt_ends_with?: Maybe<string>

    createdAt_ends_with

  • Optional createdAt_gt?: Maybe<string>

    createdAt_gt

  • Optional createdAt_gte?: Maybe<string>

    createdAt_gte

  • Optional createdAt_in?: Maybe<Array<string>>

    createdAt_in

  • Optional createdAt_lt?: Maybe<string>

    createdAt_lt

  • Optional createdAt_lte?: Maybe<string>

    createdAt_lte

  • Optional createdAt_not?: Maybe<string>

    createdAt_not

  • Optional createdAt_not_contains?: Maybe<string>

    createdAt_not_contains

  • Optional createdAt_not_ends_with?: Maybe<string>

    createdAt_not_ends_with

  • Optional createdAt_not_in?: Maybe<Array<string>>

    createdAt_not_in

  • Optional createdAt_not_starts_with?: Maybe<string>

    createdAt_not_starts_with

  • Optional createdAt_starts_with?: Maybe<string>

    createdAt_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional labels?: Maybe<_LabelFilter>

    labels

  • Optional labels_every?: Maybe<_LabelFilter>

    labels_every

  • Optional labels_in?: Maybe<_LabelFilter>

    labels_in

  • Optional labels_none?: Maybe<_LabelFilter>

    labels_none

  • Optional labels_not?: Maybe<_LabelFilter>

    labels_not

  • Optional labels_not_in?: Maybe<_LabelFilter>

    labels_not_in

  • Optional labels_single?: Maybe<_LabelFilter>

    labels_single

  • Optional labels_some?: Maybe<_LabelFilter>

    labels_some

  • Optional lastAssignedBy?: Maybe<_ScmIdFilter>

    lastAssignedBy

  • Optional lastAssignedBy_in?: Maybe<_ScmIdFilter>

    lastAssignedBy_in

  • Optional lastAssignedBy_not?: Maybe<_ScmIdFilter>

    lastAssignedBy_not

  • Optional lastAssignedBy_not_in?: Maybe<_ScmIdFilter>

    lastAssignedBy_not_in

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional number?: Maybe<number>

    number

  • Optional number_gt?: Maybe<number>

    number_gt

  • Optional number_gte?: Maybe<number>

    number_gte

  • Optional number_in?: Maybe<Array<number>>

    number_in

  • Optional number_lt?: Maybe<number>

    number_lt

  • Optional number_lte?: Maybe<number>

    number_lte

  • Optional number_not?: Maybe<number>

    number_not

  • Optional number_not_in?: Maybe<Array<number>>

    number_not_in

  • Optional openedBy?: Maybe<_ScmIdFilter>

    openedBy

  • Optional openedBy_in?: Maybe<_ScmIdFilter>

    openedBy_in

  • Optional openedBy_not?: Maybe<_ScmIdFilter>

    openedBy_not

  • Optional openedBy_not_in?: Maybe<_ScmIdFilter>

    openedBy_not_in

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional resolvingCommits?: Maybe<_CommitFilter>

    resolvingCommits

  • Optional resolvingCommits_every?: Maybe<_CommitFilter>

    resolvingCommits_every

  • Optional resolvingCommits_in?: Maybe<_CommitFilter>

    resolvingCommits_in

  • Optional resolvingCommits_none?: Maybe<_CommitFilter>

    resolvingCommits_none

  • Optional resolvingCommits_not?: Maybe<_CommitFilter>

    resolvingCommits_not

  • Optional resolvingCommits_not_in?: Maybe<_CommitFilter>

    resolvingCommits_not_in

  • Optional resolvingCommits_single?: Maybe<_CommitFilter>

    resolvingCommits_single

  • Optional resolvingCommits_some?: Maybe<_CommitFilter>

    resolvingCommits_some

  • Optional state?: Maybe<IssueState>

    state

  • Optional state_in?: Maybe<Array<IssueState>>

    state_in

  • Optional state_not?: Maybe<IssueState>

    state_not

  • Optional state_not_in?: Maybe<Array<IssueState>>

    state_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

  • Optional title?: Maybe<string>

    title

  • Optional title_contains?: Maybe<string>

    title_contains

  • Optional title_ends_with?: Maybe<string>

    title_ends_with

  • Optional title_gt?: Maybe<string>

    title_gt

  • Optional title_gte?: Maybe<string>

    title_gte

  • Optional title_in?: Maybe<Array<string>>

    title_in

  • Optional title_lt?: Maybe<string>

    title_lt

  • Optional title_lte?: Maybe<string>

    title_lte

  • Optional title_not?: Maybe<string>

    title_not

  • Optional title_not_contains?: Maybe<string>

    title_not_contains

  • Optional title_not_ends_with?: Maybe<string>

    title_not_ends_with

  • Optional title_not_in?: Maybe<Array<string>>

    title_not_in

  • Optional title_not_starts_with?: Maybe<string>

    title_not_starts_with

  • Optional title_starts_with?: Maybe<string>

    title_starts_with

  • Optional updatedAt?: Maybe<string>

    updatedAt

  • Optional updatedAt_contains?: Maybe<string>

    updatedAt_contains

  • Optional updatedAt_ends_with?: Maybe<string>

    updatedAt_ends_with

  • Optional updatedAt_gt?: Maybe<string>

    updatedAt_gt

  • Optional updatedAt_gte?: Maybe<string>

    updatedAt_gte

  • Optional updatedAt_in?: Maybe<Array<string>>

    updatedAt_in

  • Optional updatedAt_lt?: Maybe<string>

    updatedAt_lt

  • Optional updatedAt_lte?: Maybe<string>

    updatedAt_lte

  • Optional updatedAt_not?: Maybe<string>

    updatedAt_not

  • Optional updatedAt_not_contains?: Maybe<string>

    updatedAt_not_contains

  • Optional updatedAt_not_ends_with?: Maybe<string>

    updatedAt_not_ends_with

  • Optional updatedAt_not_in?: Maybe<Array<string>>

    updatedAt_not_in

  • Optional updatedAt_not_starts_with?: Maybe<string>

    updatedAt_not_starts_with

  • Optional updatedAt_starts_with?: Maybe<string>

    updatedAt_starts_with

_JobFilter

_JobFilter: object

Filter Input Type for Job

Type declaration

  • Optional AND?: Maybe<Array<_JobFilter>>

    AND

  • Optional OR?: Maybe<Array<_JobFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional finishedAt?: Maybe<string>

    finishedAt

  • Optional finishedAt_contains?: Maybe<string>

    finishedAt_contains

  • Optional finishedAt_ends_with?: Maybe<string>

    finishedAt_ends_with

  • Optional finishedAt_gt?: Maybe<string>

    finishedAt_gt

  • Optional finishedAt_gte?: Maybe<string>

    finishedAt_gte

  • Optional finishedAt_in?: Maybe<Array<string>>

    finishedAt_in

  • Optional finishedAt_lt?: Maybe<string>

    finishedAt_lt

  • Optional finishedAt_lte?: Maybe<string>

    finishedAt_lte

  • Optional finishedAt_not?: Maybe<string>

    finishedAt_not

  • Optional finishedAt_not_contains?: Maybe<string>

    finishedAt_not_contains

  • Optional finishedAt_not_ends_with?: Maybe<string>

    finishedAt_not_ends_with

  • Optional finishedAt_not_in?: Maybe<Array<string>>

    finishedAt_not_in

  • Optional finishedAt_not_starts_with?: Maybe<string>

    finishedAt_not_starts_with

  • Optional finishedAt_starts_with?: Maybe<string>

    finishedAt_starts_with

  • Optional jobId?: Maybe<string>

    jobId

  • Optional jobId_contains?: Maybe<string>

    jobId_contains

  • Optional jobId_ends_with?: Maybe<string>

    jobId_ends_with

  • Optional jobId_gt?: Maybe<string>

    jobId_gt

  • Optional jobId_gte?: Maybe<string>

    jobId_gte

  • Optional jobId_in?: Maybe<Array<string>>

    jobId_in

  • Optional jobId_lt?: Maybe<string>

    jobId_lt

  • Optional jobId_lte?: Maybe<string>

    jobId_lte

  • Optional jobId_not?: Maybe<string>

    jobId_not

  • Optional jobId_not_contains?: Maybe<string>

    jobId_not_contains

  • Optional jobId_not_ends_with?: Maybe<string>

    jobId_not_ends_with

  • Optional jobId_not_in?: Maybe<Array<string>>

    jobId_not_in

  • Optional jobId_not_starts_with?: Maybe<string>

    jobId_not_starts_with

  • Optional jobId_starts_with?: Maybe<string>

    jobId_starts_with

  • Optional manual?: Maybe<boolean>

    manual

  • Optional manual_not?: Maybe<boolean>

    manual_not

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional runner?: Maybe<string>

    runner

  • Optional runner_contains?: Maybe<string>

    runner_contains

  • Optional runner_ends_with?: Maybe<string>

    runner_ends_with

  • Optional runner_gt?: Maybe<string>

    runner_gt

  • Optional runner_gte?: Maybe<string>

    runner_gte

  • Optional runner_in?: Maybe<Array<string>>

    runner_in

  • Optional runner_lt?: Maybe<string>

    runner_lt

  • Optional runner_lte?: Maybe<string>

    runner_lte

  • Optional runner_not?: Maybe<string>

    runner_not

  • Optional runner_not_contains?: Maybe<string>

    runner_not_contains

  • Optional runner_not_ends_with?: Maybe<string>

    runner_not_ends_with

  • Optional runner_not_in?: Maybe<Array<string>>

    runner_not_in

  • Optional runner_not_starts_with?: Maybe<string>

    runner_not_starts_with

  • Optional runner_starts_with?: Maybe<string>

    runner_starts_with

  • Optional stage?: Maybe<_StageFilter>

    stage

  • Optional stage_in?: Maybe<_StageFilter>

    stage_in

  • Optional stage_not?: Maybe<_StageFilter>

    stage_not

  • Optional stage_not_in?: Maybe<_StageFilter>

    stage_not_in

  • Optional startedAt?: Maybe<string>

    startedAt

  • Optional startedAt_contains?: Maybe<string>

    startedAt_contains

  • Optional startedAt_ends_with?: Maybe<string>

    startedAt_ends_with

  • Optional startedAt_gt?: Maybe<string>

    startedAt_gt

  • Optional startedAt_gte?: Maybe<string>

    startedAt_gte

  • Optional startedAt_in?: Maybe<Array<string>>

    startedAt_in

  • Optional startedAt_lt?: Maybe<string>

    startedAt_lt

  • Optional startedAt_lte?: Maybe<string>

    startedAt_lte

  • Optional startedAt_not?: Maybe<string>

    startedAt_not

  • Optional startedAt_not_contains?: Maybe<string>

    startedAt_not_contains

  • Optional startedAt_not_ends_with?: Maybe<string>

    startedAt_not_ends_with

  • Optional startedAt_not_in?: Maybe<Array<string>>

    startedAt_not_in

  • Optional startedAt_not_starts_with?: Maybe<string>

    startedAt_not_starts_with

  • Optional startedAt_starts_with?: Maybe<string>

    startedAt_starts_with

  • Optional status?: Maybe<JobStatus>

    status

  • Optional status_in?: Maybe<Array<JobStatus>>

    status_in

  • Optional status_not?: Maybe<JobStatus>

    status_not

  • Optional status_not_in?: Maybe<Array<JobStatus>>

    status_not_in

  • Optional when?: Maybe<string>

    when

  • Optional when_contains?: Maybe<string>

    when_contains

  • Optional when_ends_with?: Maybe<string>

    when_ends_with

  • Optional when_gt?: Maybe<string>

    when_gt

  • Optional when_gte?: Maybe<string>

    when_gte

  • Optional when_in?: Maybe<Array<string>>

    when_in

  • Optional when_lt?: Maybe<string>

    when_lt

  • Optional when_lte?: Maybe<string>

    when_lte

  • Optional when_not?: Maybe<string>

    when_not

  • Optional when_not_contains?: Maybe<string>

    when_not_contains

  • Optional when_not_ends_with?: Maybe<string>

    when_not_ends_with

  • Optional when_not_in?: Maybe<Array<string>>

    when_not_in

  • Optional when_not_starts_with?: Maybe<string>

    when_not_starts_with

  • Optional when_starts_with?: Maybe<string>

    when_starts_with

_K8ContainerFilter

_K8ContainerFilter: object

Filter Input Type for K8Container

Type declaration

  • Optional AND?: Maybe<Array<_K8ContainerFilter>>

    AND

  • Optional OR?: Maybe<Array<_K8ContainerFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional containerID?: Maybe<string>

    containerID

  • Optional containerID_contains?: Maybe<string>

    containerID_contains

  • Optional containerID_ends_with?: Maybe<string>

    containerID_ends_with

  • Optional containerID_gt?: Maybe<string>

    containerID_gt

  • Optional containerID_gte?: Maybe<string>

    containerID_gte

  • Optional containerID_in?: Maybe<Array<string>>

    containerID_in

  • Optional containerID_lt?: Maybe<string>

    containerID_lt

  • Optional containerID_lte?: Maybe<string>

    containerID_lte

  • Optional containerID_not?: Maybe<string>

    containerID_not

  • Optional containerID_not_contains?: Maybe<string>

    containerID_not_contains

  • Optional containerID_not_ends_with?: Maybe<string>

    containerID_not_ends_with

  • Optional containerID_not_in?: Maybe<Array<string>>

    containerID_not_in

  • Optional containerID_not_starts_with?: Maybe<string>

    containerID_not_starts_with

  • Optional containerID_starts_with?: Maybe<string>

    containerID_starts_with

  • Optional containerJSON?: Maybe<string>

    containerJSON

  • Optional containerJSON_contains?: Maybe<string>

    containerJSON_contains

  • Optional containerJSON_ends_with?: Maybe<string>

    containerJSON_ends_with

  • Optional containerJSON_gt?: Maybe<string>

    containerJSON_gt

  • Optional containerJSON_gte?: Maybe<string>

    containerJSON_gte

  • Optional containerJSON_in?: Maybe<Array<string>>

    containerJSON_in

  • Optional containerJSON_lt?: Maybe<string>

    containerJSON_lt

  • Optional containerJSON_lte?: Maybe<string>

    containerJSON_lte

  • Optional containerJSON_not?: Maybe<string>

    containerJSON_not

  • Optional containerJSON_not_contains?: Maybe<string>

    containerJSON_not_contains

  • Optional containerJSON_not_ends_with?: Maybe<string>

    containerJSON_not_ends_with

  • Optional containerJSON_not_in?: Maybe<Array<string>>

    containerJSON_not_in

  • Optional containerJSON_not_starts_with?: Maybe<string>

    containerJSON_not_starts_with

  • Optional containerJSON_starts_with?: Maybe<string>

    containerJSON_starts_with

  • Optional environment?: Maybe<string>

    environment

  • Optional environment_contains?: Maybe<string>

    environment_contains

  • Optional environment_ends_with?: Maybe<string>

    environment_ends_with

  • Optional environment_gt?: Maybe<string>

    environment_gt

  • Optional environment_gte?: Maybe<string>

    environment_gte

  • Optional environment_in?: Maybe<Array<string>>

    environment_in

  • Optional environment_lt?: Maybe<string>

    environment_lt

  • Optional environment_lte?: Maybe<string>

    environment_lte

  • Optional environment_not?: Maybe<string>

    environment_not

  • Optional environment_not_contains?: Maybe<string>

    environment_not_contains

  • Optional environment_not_ends_with?: Maybe<string>

    environment_not_ends_with

  • Optional environment_not_in?: Maybe<Array<string>>

    environment_not_in

  • Optional environment_not_starts_with?: Maybe<string>

    environment_not_starts_with

  • Optional environment_starts_with?: Maybe<string>

    environment_starts_with

  • Optional image?: Maybe<_DockerImageFilter>

    image

  • Optional imageName?: Maybe<string>

    imageName

  • Optional imageName_contains?: Maybe<string>

    imageName_contains

  • Optional imageName_ends_with?: Maybe<string>

    imageName_ends_with

  • Optional imageName_gt?: Maybe<string>

    imageName_gt

  • Optional imageName_gte?: Maybe<string>

    imageName_gte

  • Optional imageName_in?: Maybe<Array<string>>

    imageName_in

  • Optional imageName_lt?: Maybe<string>

    imageName_lt

  • Optional imageName_lte?: Maybe<string>

    imageName_lte

  • Optional imageName_not?: Maybe<string>

    imageName_not

  • Optional imageName_not_contains?: Maybe<string>

    imageName_not_contains

  • Optional imageName_not_ends_with?: Maybe<string>

    imageName_not_ends_with

  • Optional imageName_not_in?: Maybe<Array<string>>

    imageName_not_in

  • Optional imageName_not_starts_with?: Maybe<string>

    imageName_not_starts_with

  • Optional imageName_starts_with?: Maybe<string>

    imageName_starts_with

  • Optional image_in?: Maybe<_DockerImageFilter>

    image_in

  • Optional image_not?: Maybe<_DockerImageFilter>

    image_not

  • Optional image_not_in?: Maybe<_DockerImageFilter>

    image_not_in

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional pod?: Maybe<_K8PodFilter>

    pod

  • Optional pod_in?: Maybe<_K8PodFilter>

    pod_in

  • Optional pod_not?: Maybe<_K8PodFilter>

    pod_not

  • Optional pod_not_in?: Maybe<_K8PodFilter>

    pod_not_in

  • Optional ready?: Maybe<boolean>

    ready

  • Optional ready_not?: Maybe<boolean>

    ready_not

  • Optional resourceVersion?: Maybe<number>

    resourceVersion

  • Optional resourceVersion_gt?: Maybe<number>

    resourceVersion_gt

  • Optional resourceVersion_gte?: Maybe<number>

    resourceVersion_gte

  • Optional resourceVersion_in?: Maybe<Array<number>>

    resourceVersion_in

  • Optional resourceVersion_lt?: Maybe<number>

    resourceVersion_lt

  • Optional resourceVersion_lte?: Maybe<number>

    resourceVersion_lte

  • Optional resourceVersion_not?: Maybe<number>

    resourceVersion_not

  • Optional resourceVersion_not_in?: Maybe<Array<number>>

    resourceVersion_not_in

  • Optional restartCount?: Maybe<number>

    restartCount

  • Optional restartCount_gt?: Maybe<number>

    restartCount_gt

  • Optional restartCount_gte?: Maybe<number>

    restartCount_gte

  • Optional restartCount_in?: Maybe<Array<number>>

    restartCount_in

  • Optional restartCount_lt?: Maybe<number>

    restartCount_lt

  • Optional restartCount_lte?: Maybe<number>

    restartCount_lte

  • Optional restartCount_not?: Maybe<number>

    restartCount_not

  • Optional restartCount_not_in?: Maybe<Array<number>>

    restartCount_not_in

  • Optional state?: Maybe<string>

    state

  • Optional stateReason?: Maybe<string>

    stateReason

  • Optional stateReason_contains?: Maybe<string>

    stateReason_contains

  • Optional stateReason_ends_with?: Maybe<string>

    stateReason_ends_with

  • Optional stateReason_gt?: Maybe<string>

    stateReason_gt

  • Optional stateReason_gte?: Maybe<string>

    stateReason_gte

  • Optional stateReason_in?: Maybe<Array<string>>

    stateReason_in

  • Optional stateReason_lt?: Maybe<string>

    stateReason_lt

  • Optional stateReason_lte?: Maybe<string>

    stateReason_lte

  • Optional stateReason_not?: Maybe<string>

    stateReason_not

  • Optional stateReason_not_contains?: Maybe<string>

    stateReason_not_contains

  • Optional stateReason_not_ends_with?: Maybe<string>

    stateReason_not_ends_with

  • Optional stateReason_not_in?: Maybe<Array<string>>

    stateReason_not_in

  • Optional stateReason_not_starts_with?: Maybe<string>

    stateReason_not_starts_with

  • Optional stateReason_starts_with?: Maybe<string>

    stateReason_starts_with

  • Optional state_contains?: Maybe<string>

    state_contains

  • Optional state_ends_with?: Maybe<string>

    state_ends_with

  • Optional state_gt?: Maybe<string>

    state_gt

  • Optional state_gte?: Maybe<string>

    state_gte

  • Optional state_in?: Maybe<Array<string>>

    state_in

  • Optional state_lt?: Maybe<string>

    state_lt

  • Optional state_lte?: Maybe<string>

    state_lte

  • Optional state_not?: Maybe<string>

    state_not

  • Optional state_not_contains?: Maybe<string>

    state_not_contains

  • Optional state_not_ends_with?: Maybe<string>

    state_not_ends_with

  • Optional state_not_in?: Maybe<Array<string>>

    state_not_in

  • Optional state_not_starts_with?: Maybe<string>

    state_not_starts_with

  • Optional state_starts_with?: Maybe<string>

    state_starts_with

  • Optional statusJSON?: Maybe<string>

    statusJSON

  • Optional statusJSON_contains?: Maybe<string>

    statusJSON_contains

  • Optional statusJSON_ends_with?: Maybe<string>

    statusJSON_ends_with

  • Optional statusJSON_gt?: Maybe<string>

    statusJSON_gt

  • Optional statusJSON_gte?: Maybe<string>

    statusJSON_gte

  • Optional statusJSON_in?: Maybe<Array<string>>

    statusJSON_in

  • Optional statusJSON_lt?: Maybe<string>

    statusJSON_lt

  • Optional statusJSON_lte?: Maybe<string>

    statusJSON_lte

  • Optional statusJSON_not?: Maybe<string>

    statusJSON_not

  • Optional statusJSON_not_contains?: Maybe<string>

    statusJSON_not_contains

  • Optional statusJSON_not_ends_with?: Maybe<string>

    statusJSON_not_ends_with

  • Optional statusJSON_not_in?: Maybe<Array<string>>

    statusJSON_not_in

  • Optional statusJSON_not_starts_with?: Maybe<string>

    statusJSON_not_starts_with

  • Optional statusJSON_starts_with?: Maybe<string>

    statusJSON_starts_with

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_K8PodFilter

_K8PodFilter: object

Filter Input Type for K8Pod

Type declaration

  • Optional AND?: Maybe<Array<_K8PodFilter>>

    AND

  • Optional OR?: Maybe<Array<_K8PodFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional baseName?: Maybe<string>

    baseName

  • Optional baseName_contains?: Maybe<string>

    baseName_contains

  • Optional baseName_ends_with?: Maybe<string>

    baseName_ends_with

  • Optional baseName_gt?: Maybe<string>

    baseName_gt

  • Optional baseName_gte?: Maybe<string>

    baseName_gte

  • Optional baseName_in?: Maybe<Array<string>>

    baseName_in

  • Optional baseName_lt?: Maybe<string>

    baseName_lt

  • Optional baseName_lte?: Maybe<string>

    baseName_lte

  • Optional baseName_not?: Maybe<string>

    baseName_not

  • Optional baseName_not_contains?: Maybe<string>

    baseName_not_contains

  • Optional baseName_not_ends_with?: Maybe<string>

    baseName_not_ends_with

  • Optional baseName_not_in?: Maybe<Array<string>>

    baseName_not_in

  • Optional baseName_not_starts_with?: Maybe<string>

    baseName_not_starts_with

  • Optional baseName_starts_with?: Maybe<string>

    baseName_starts_with

  • Optional containers?: Maybe<_K8ContainerFilter>

    containers

  • Optional containersCrashLoopBackOff?: Maybe<boolean>

    containersCrashLoopBackOff

  • Optional containersCrashLoopBackOff_not?: Maybe<boolean>

    containersCrashLoopBackOff_not

  • Optional containers_every?: Maybe<_K8ContainerFilter>

    containers_every

  • Optional containers_in?: Maybe<_K8ContainerFilter>

    containers_in

  • Optional containers_none?: Maybe<_K8ContainerFilter>

    containers_none

  • Optional containers_not?: Maybe<_K8ContainerFilter>

    containers_not

  • Optional containers_not_in?: Maybe<_K8ContainerFilter>

    containers_not_in

  • Optional containers_single?: Maybe<_K8ContainerFilter>

    containers_single

  • Optional containers_some?: Maybe<_K8ContainerFilter>

    containers_some

  • Optional envJSON?: Maybe<string>

    envJSON

  • Optional envJSON_contains?: Maybe<string>

    envJSON_contains

  • Optional envJSON_ends_with?: Maybe<string>

    envJSON_ends_with

  • Optional envJSON_gt?: Maybe<string>

    envJSON_gt

  • Optional envJSON_gte?: Maybe<string>

    envJSON_gte

  • Optional envJSON_in?: Maybe<Array<string>>

    envJSON_in

  • Optional envJSON_lt?: Maybe<string>

    envJSON_lt

  • Optional envJSON_lte?: Maybe<string>

    envJSON_lte

  • Optional envJSON_not?: Maybe<string>

    envJSON_not

  • Optional envJSON_not_contains?: Maybe<string>

    envJSON_not_contains

  • Optional envJSON_not_ends_with?: Maybe<string>

    envJSON_not_ends_with

  • Optional envJSON_not_in?: Maybe<Array<string>>

    envJSON_not_in

  • Optional envJSON_not_starts_with?: Maybe<string>

    envJSON_not_starts_with

  • Optional envJSON_starts_with?: Maybe<string>

    envJSON_starts_with

  • Optional environment?: Maybe<string>

    environment

  • Optional environment_contains?: Maybe<string>

    environment_contains

  • Optional environment_ends_with?: Maybe<string>

    environment_ends_with

  • Optional environment_gt?: Maybe<string>

    environment_gt

  • Optional environment_gte?: Maybe<string>

    environment_gte

  • Optional environment_in?: Maybe<Array<string>>

    environment_in

  • Optional environment_lt?: Maybe<string>

    environment_lt

  • Optional environment_lte?: Maybe<string>

    environment_lte

  • Optional environment_not?: Maybe<string>

    environment_not

  • Optional environment_not_contains?: Maybe<string>

    environment_not_contains

  • Optional environment_not_ends_with?: Maybe<string>

    environment_not_ends_with

  • Optional environment_not_in?: Maybe<Array<string>>

    environment_not_in

  • Optional environment_not_starts_with?: Maybe<string>

    environment_not_starts_with

  • Optional environment_starts_with?: Maybe<string>

    environment_starts_with

  • Optional host?: Maybe<string>

    host

  • Optional host_contains?: Maybe<string>

    host_contains

  • Optional host_ends_with?: Maybe<string>

    host_ends_with

  • Optional host_gt?: Maybe<string>

    host_gt

  • Optional host_gte?: Maybe<string>

    host_gte

  • Optional host_in?: Maybe<Array<string>>

    host_in

  • Optional host_lt?: Maybe<string>

    host_lt

  • Optional host_lte?: Maybe<string>

    host_lte

  • Optional host_not?: Maybe<string>

    host_not

  • Optional host_not_contains?: Maybe<string>

    host_not_contains

  • Optional host_not_ends_with?: Maybe<string>

    host_not_ends_with

  • Optional host_not_in?: Maybe<Array<string>>

    host_not_in

  • Optional host_not_starts_with?: Maybe<string>

    host_not_starts_with

  • Optional host_starts_with?: Maybe<string>

    host_starts_with

  • Optional images?: Maybe<_DockerImageFilter>

    images

  • Optional images_every?: Maybe<_DockerImageFilter>

    images_every

  • Optional images_in?: Maybe<_DockerImageFilter>

    images_in

  • Optional images_none?: Maybe<_DockerImageFilter>

    images_none

  • Optional images_not?: Maybe<_DockerImageFilter>

    images_not

  • Optional images_not_in?: Maybe<_DockerImageFilter>

    images_not_in

  • Optional images_single?: Maybe<_DockerImageFilter>

    images_single

  • Optional images_some?: Maybe<_DockerImageFilter>

    images_some

  • Optional metadataJSON?: Maybe<string>

    metadataJSON

  • Optional metadataJSON_contains?: Maybe<string>

    metadataJSON_contains

  • Optional metadataJSON_ends_with?: Maybe<string>

    metadataJSON_ends_with

  • Optional metadataJSON_gt?: Maybe<string>

    metadataJSON_gt

  • Optional metadataJSON_gte?: Maybe<string>

    metadataJSON_gte

  • Optional metadataJSON_in?: Maybe<Array<string>>

    metadataJSON_in

  • Optional metadataJSON_lt?: Maybe<string>

    metadataJSON_lt

  • Optional metadataJSON_lte?: Maybe<string>

    metadataJSON_lte

  • Optional metadataJSON_not?: Maybe<string>

    metadataJSON_not

  • Optional metadataJSON_not_contains?: Maybe<string>

    metadataJSON_not_contains

  • Optional metadataJSON_not_ends_with?: Maybe<string>

    metadataJSON_not_ends_with

  • Optional metadataJSON_not_in?: Maybe<Array<string>>

    metadataJSON_not_in

  • Optional metadataJSON_not_starts_with?: Maybe<string>

    metadataJSON_not_starts_with

  • Optional metadataJSON_starts_with?: Maybe<string>

    metadataJSON_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional namespace?: Maybe<string>

    namespace

  • Optional namespace_contains?: Maybe<string>

    namespace_contains

  • Optional namespace_ends_with?: Maybe<string>

    namespace_ends_with

  • Optional namespace_gt?: Maybe<string>

    namespace_gt

  • Optional namespace_gte?: Maybe<string>

    namespace_gte

  • Optional namespace_in?: Maybe<Array<string>>

    namespace_in

  • Optional namespace_lt?: Maybe<string>

    namespace_lt

  • Optional namespace_lte?: Maybe<string>

    namespace_lte

  • Optional namespace_not?: Maybe<string>

    namespace_not

  • Optional namespace_not_contains?: Maybe<string>

    namespace_not_contains

  • Optional namespace_not_ends_with?: Maybe<string>

    namespace_not_ends_with

  • Optional namespace_not_in?: Maybe<Array<string>>

    namespace_not_in

  • Optional namespace_not_starts_with?: Maybe<string>

    namespace_not_starts_with

  • Optional namespace_starts_with?: Maybe<string>

    namespace_starts_with

  • Optional phase?: Maybe<string>

    phase

  • Optional phase_contains?: Maybe<string>

    phase_contains

  • Optional phase_ends_with?: Maybe<string>

    phase_ends_with

  • Optional phase_gt?: Maybe<string>

    phase_gt

  • Optional phase_gte?: Maybe<string>

    phase_gte

  • Optional phase_in?: Maybe<Array<string>>

    phase_in

  • Optional phase_lt?: Maybe<string>

    phase_lt

  • Optional phase_lte?: Maybe<string>

    phase_lte

  • Optional phase_not?: Maybe<string>

    phase_not

  • Optional phase_not_contains?: Maybe<string>

    phase_not_contains

  • Optional phase_not_ends_with?: Maybe<string>

    phase_not_ends_with

  • Optional phase_not_in?: Maybe<Array<string>>

    phase_not_in

  • Optional phase_not_starts_with?: Maybe<string>

    phase_not_starts_with

  • Optional phase_starts_with?: Maybe<string>

    phase_starts_with

  • Optional resourceVersion?: Maybe<number>

    resourceVersion

  • Optional resourceVersion_gt?: Maybe<number>

    resourceVersion_gt

  • Optional resourceVersion_gte?: Maybe<number>

    resourceVersion_gte

  • Optional resourceVersion_in?: Maybe<Array<number>>

    resourceVersion_in

  • Optional resourceVersion_lt?: Maybe<number>

    resourceVersion_lt

  • Optional resourceVersion_lte?: Maybe<number>

    resourceVersion_lte

  • Optional resourceVersion_not?: Maybe<number>

    resourceVersion_not

  • Optional resourceVersion_not_in?: Maybe<Array<number>>

    resourceVersion_not_in

  • Optional specsJSON?: Maybe<string>

    specsJSON

  • Optional specsJSON_contains?: Maybe<string>

    specsJSON_contains

  • Optional specsJSON_ends_with?: Maybe<string>

    specsJSON_ends_with

  • Optional specsJSON_gt?: Maybe<string>

    specsJSON_gt

  • Optional specsJSON_gte?: Maybe<string>

    specsJSON_gte

  • Optional specsJSON_in?: Maybe<Array<string>>

    specsJSON_in

  • Optional specsJSON_lt?: Maybe<string>

    specsJSON_lt

  • Optional specsJSON_lte?: Maybe<string>

    specsJSON_lte

  • Optional specsJSON_not?: Maybe<string>

    specsJSON_not

  • Optional specsJSON_not_contains?: Maybe<string>

    specsJSON_not_contains

  • Optional specsJSON_not_ends_with?: Maybe<string>

    specsJSON_not_ends_with

  • Optional specsJSON_not_in?: Maybe<Array<string>>

    specsJSON_not_in

  • Optional specsJSON_not_starts_with?: Maybe<string>

    specsJSON_not_starts_with

  • Optional specsJSON_starts_with?: Maybe<string>

    specsJSON_starts_with

  • Optional state?: Maybe<string>

    state

  • Optional state_contains?: Maybe<string>

    state_contains

  • Optional state_ends_with?: Maybe<string>

    state_ends_with

  • Optional state_gt?: Maybe<string>

    state_gt

  • Optional state_gte?: Maybe<string>

    state_gte

  • Optional state_in?: Maybe<Array<string>>

    state_in

  • Optional state_lt?: Maybe<string>

    state_lt

  • Optional state_lte?: Maybe<string>

    state_lte

  • Optional state_not?: Maybe<string>

    state_not

  • Optional state_not_contains?: Maybe<string>

    state_not_contains

  • Optional state_not_ends_with?: Maybe<string>

    state_not_ends_with

  • Optional state_not_in?: Maybe<Array<string>>

    state_not_in

  • Optional state_not_starts_with?: Maybe<string>

    state_not_starts_with

  • Optional state_starts_with?: Maybe<string>

    state_starts_with

  • Optional statusJSON?: Maybe<string>

    statusJSON

  • Optional statusJSON_contains?: Maybe<string>

    statusJSON_contains

  • Optional statusJSON_ends_with?: Maybe<string>

    statusJSON_ends_with

  • Optional statusJSON_gt?: Maybe<string>

    statusJSON_gt

  • Optional statusJSON_gte?: Maybe<string>

    statusJSON_gte

  • Optional statusJSON_in?: Maybe<Array<string>>

    statusJSON_in

  • Optional statusJSON_lt?: Maybe<string>

    statusJSON_lt

  • Optional statusJSON_lte?: Maybe<string>

    statusJSON_lte

  • Optional statusJSON_not?: Maybe<string>

    statusJSON_not

  • Optional statusJSON_not_contains?: Maybe<string>

    statusJSON_not_contains

  • Optional statusJSON_not_ends_with?: Maybe<string>

    statusJSON_not_ends_with

  • Optional statusJSON_not_in?: Maybe<Array<string>>

    statusJSON_not_in

  • Optional statusJSON_not_starts_with?: Maybe<string>

    statusJSON_not_starts_with

  • Optional statusJSON_starts_with?: Maybe<string>

    statusJSON_starts_with

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_LabelFilter

_LabelFilter: object

Filter Input Type for Label

Type declaration

  • Optional AND?: Maybe<Array<_LabelFilter>>

    AND

  • Optional OR?: Maybe<Array<_LabelFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional color?: Maybe<string>

    color

  • Optional color_contains?: Maybe<string>

    color_contains

  • Optional color_ends_with?: Maybe<string>

    color_ends_with

  • Optional color_gt?: Maybe<string>

    color_gt

  • Optional color_gte?: Maybe<string>

    color_gte

  • Optional color_in?: Maybe<Array<string>>

    color_in

  • Optional color_lt?: Maybe<string>

    color_lt

  • Optional color_lte?: Maybe<string>

    color_lte

  • Optional color_not?: Maybe<string>

    color_not

  • Optional color_not_contains?: Maybe<string>

    color_not_contains

  • Optional color_not_ends_with?: Maybe<string>

    color_not_ends_with

  • Optional color_not_in?: Maybe<Array<string>>

    color_not_in

  • Optional color_not_starts_with?: Maybe<string>

    color_not_starts_with

  • Optional color_starts_with?: Maybe<string>

    color_starts_with

  • Optional default?: Maybe<string>

    default

  • Optional default_contains?: Maybe<string>

    default_contains

  • Optional default_ends_with?: Maybe<string>

    default_ends_with

  • Optional default_gt?: Maybe<string>

    default_gt

  • Optional default_gte?: Maybe<string>

    default_gte

  • Optional default_in?: Maybe<Array<string>>

    default_in

  • Optional default_lt?: Maybe<string>

    default_lt

  • Optional default_lte?: Maybe<string>

    default_lte

  • Optional default_not?: Maybe<string>

    default_not

  • Optional default_not_contains?: Maybe<string>

    default_not_contains

  • Optional default_not_ends_with?: Maybe<string>

    default_not_ends_with

  • Optional default_not_in?: Maybe<Array<string>>

    default_not_in

  • Optional default_not_starts_with?: Maybe<string>

    default_not_starts_with

  • Optional default_starts_with?: Maybe<string>

    default_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

_OrgFilter

_OrgFilter: object

Filter Input Type for Org

Type declaration

_ParentImpactFilter

_ParentImpactFilter: object

Filter Input Type for ParentImpact

Type declaration

  • Optional AND?: Maybe<Array<_ParentImpactFilter>>

    AND

  • Optional OR?: Maybe<Array<_ParentImpactFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional commits?: Maybe<_CommitFilter>

    commits

  • Optional commits_every?: Maybe<_CommitFilter>

    commits_every

  • Optional commits_in?: Maybe<_CommitFilter>

    commits_in

  • Optional commits_none?: Maybe<_CommitFilter>

    commits_none

  • Optional commits_not?: Maybe<_CommitFilter>

    commits_not

  • Optional commits_not_in?: Maybe<_CommitFilter>

    commits_not_in

  • Optional commits_single?: Maybe<_CommitFilter>

    commits_single

  • Optional commits_some?: Maybe<_CommitFilter>

    commits_some

  • Optional data?: Maybe<string>

    data

  • Optional data_contains?: Maybe<string>

    data_contains

  • Optional data_ends_with?: Maybe<string>

    data_ends_with

  • Optional data_gt?: Maybe<string>

    data_gt

  • Optional data_gte?: Maybe<string>

    data_gte

  • Optional data_in?: Maybe<Array<string>>

    data_in

  • Optional data_lt?: Maybe<string>

    data_lt

  • Optional data_lte?: Maybe<string>

    data_lte

  • Optional data_not?: Maybe<string>

    data_not

  • Optional data_not_contains?: Maybe<string>

    data_not_contains

  • Optional data_not_ends_with?: Maybe<string>

    data_not_ends_with

  • Optional data_not_in?: Maybe<Array<string>>

    data_not_in

  • Optional data_not_starts_with?: Maybe<string>

    data_not_starts_with

  • Optional data_starts_with?: Maybe<string>

    data_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

_PersonFilter

_PersonFilter: object

Filter Input Type for Person

Type declaration

  • Optional AND?: Maybe<Array<_PersonFilter>>

    AND

  • Optional OR?: Maybe<Array<_PersonFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional chatId?: Maybe<_ChatIdFilter>

    chatId

  • Optional chatId_in?: Maybe<_ChatIdFilter>

    chatId_in

  • Optional chatId_not?: Maybe<_ChatIdFilter>

    chatId_not

  • Optional chatId_not_in?: Maybe<_ChatIdFilter>

    chatId_not_in

  • Optional emails?: Maybe<_EmailFilter>

    emails

  • Optional emails_every?: Maybe<_EmailFilter>

    emails_every

  • Optional emails_in?: Maybe<_EmailFilter>

    emails_in

  • Optional emails_none?: Maybe<_EmailFilter>

    emails_none

  • Optional emails_not?: Maybe<_EmailFilter>

    emails_not

  • Optional emails_not_in?: Maybe<_EmailFilter>

    emails_not_in

  • Optional emails_single?: Maybe<_EmailFilter>

    emails_single

  • Optional emails_some?: Maybe<_EmailFilter>

    emails_some

  • Optional forename?: Maybe<string>

    forename

  • Optional forename_contains?: Maybe<string>

    forename_contains

  • Optional forename_ends_with?: Maybe<string>

    forename_ends_with

  • Optional forename_gt?: Maybe<string>

    forename_gt

  • Optional forename_gte?: Maybe<string>

    forename_gte

  • Optional forename_in?: Maybe<Array<string>>

    forename_in

  • Optional forename_lt?: Maybe<string>

    forename_lt

  • Optional forename_lte?: Maybe<string>

    forename_lte

  • Optional forename_not?: Maybe<string>

    forename_not

  • Optional forename_not_contains?: Maybe<string>

    forename_not_contains

  • Optional forename_not_ends_with?: Maybe<string>

    forename_not_ends_with

  • Optional forename_not_in?: Maybe<Array<string>>

    forename_not_in

  • Optional forename_not_starts_with?: Maybe<string>

    forename_not_starts_with

  • Optional forename_starts_with?: Maybe<string>

    forename_starts_with

  • Optional gitHubId?: Maybe<_GitHubIdFilter>

    gitHubId

  • Optional gitHubId_in?: Maybe<_GitHubIdFilter>

    gitHubId_in

  • Optional gitHubId_not?: Maybe<_GitHubIdFilter>

    gitHubId_not

  • Optional gitHubId_not_in?: Maybe<_GitHubIdFilter>

    gitHubId_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional scmId?: Maybe<_ScmIdFilter>

    scmId

  • Optional scmId_in?: Maybe<_ScmIdFilter>

    scmId_in

  • Optional scmId_not?: Maybe<_ScmIdFilter>

    scmId_not

  • Optional scmId_not_in?: Maybe<_ScmIdFilter>

    scmId_not_in

  • Optional surname?: Maybe<string>

    surname

  • Optional surname_contains?: Maybe<string>

    surname_contains

  • Optional surname_ends_with?: Maybe<string>

    surname_ends_with

  • Optional surname_gt?: Maybe<string>

    surname_gt

  • Optional surname_gte?: Maybe<string>

    surname_gte

  • Optional surname_in?: Maybe<Array<string>>

    surname_in

  • Optional surname_lt?: Maybe<string>

    surname_lt

  • Optional surname_lte?: Maybe<string>

    surname_lte

  • Optional surname_not?: Maybe<string>

    surname_not

  • Optional surname_not_contains?: Maybe<string>

    surname_not_contains

  • Optional surname_not_ends_with?: Maybe<string>

    surname_not_ends_with

  • Optional surname_not_in?: Maybe<Array<string>>

    surname_not_in

  • Optional surname_not_starts_with?: Maybe<string>

    surname_not_starts_with

  • Optional surname_starts_with?: Maybe<string>

    surname_starts_with

  • Optional team?: Maybe<_TeamFilter>

    team

  • Optional team_in?: Maybe<_TeamFilter>

    team_in

  • Optional team_not?: Maybe<_TeamFilter>

    team_not

  • Optional team_not_in?: Maybe<_TeamFilter>

    team_not_in

_PipelineFilter

_PipelineFilter: object

Filter Input Type for Pipeline

Type declaration

  • Optional AND?: Maybe<Array<_PipelineFilter>>

    AND

  • Optional OR?: Maybe<Array<_PipelineFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional createdAt?: Maybe<string>

    createdAt

  • Optional createdAt_contains?: Maybe<string>

    createdAt_contains

  • Optional createdAt_ends_with?: Maybe<string>

    createdAt_ends_with

  • Optional createdAt_gt?: Maybe<string>

    createdAt_gt

  • Optional createdAt_gte?: Maybe<string>

    createdAt_gte

  • Optional createdAt_in?: Maybe<Array<string>>

    createdAt_in

  • Optional createdAt_lt?: Maybe<string>

    createdAt_lt

  • Optional createdAt_lte?: Maybe<string>

    createdAt_lte

  • Optional createdAt_not?: Maybe<string>

    createdAt_not

  • Optional createdAt_not_contains?: Maybe<string>

    createdAt_not_contains

  • Optional createdAt_not_ends_with?: Maybe<string>

    createdAt_not_ends_with

  • Optional createdAt_not_in?: Maybe<Array<string>>

    createdAt_not_in

  • Optional createdAt_not_starts_with?: Maybe<string>

    createdAt_not_starts_with

  • Optional createdAt_starts_with?: Maybe<string>

    createdAt_starts_with

  • Optional finishedAt?: Maybe<string>

    finishedAt

  • Optional finishedAt_contains?: Maybe<string>

    finishedAt_contains

  • Optional finishedAt_ends_with?: Maybe<string>

    finishedAt_ends_with

  • Optional finishedAt_gt?: Maybe<string>

    finishedAt_gt

  • Optional finishedAt_gte?: Maybe<string>

    finishedAt_gte

  • Optional finishedAt_in?: Maybe<Array<string>>

    finishedAt_in

  • Optional finishedAt_lt?: Maybe<string>

    finishedAt_lt

  • Optional finishedAt_lte?: Maybe<string>

    finishedAt_lte

  • Optional finishedAt_not?: Maybe<string>

    finishedAt_not

  • Optional finishedAt_not_contains?: Maybe<string>

    finishedAt_not_contains

  • Optional finishedAt_not_ends_with?: Maybe<string>

    finishedAt_not_ends_with

  • Optional finishedAt_not_in?: Maybe<Array<string>>

    finishedAt_not_in

  • Optional finishedAt_not_starts_with?: Maybe<string>

    finishedAt_not_starts_with

  • Optional finishedAt_starts_with?: Maybe<string>

    finishedAt_starts_with

  • Optional pipelineId?: Maybe<string>

    pipelineId

  • Optional pipelineId_contains?: Maybe<string>

    pipelineId_contains

  • Optional pipelineId_ends_with?: Maybe<string>

    pipelineId_ends_with

  • Optional pipelineId_gt?: Maybe<string>

    pipelineId_gt

  • Optional pipelineId_gte?: Maybe<string>

    pipelineId_gte

  • Optional pipelineId_in?: Maybe<Array<string>>

    pipelineId_in

  • Optional pipelineId_lt?: Maybe<string>

    pipelineId_lt

  • Optional pipelineId_lte?: Maybe<string>

    pipelineId_lte

  • Optional pipelineId_not?: Maybe<string>

    pipelineId_not

  • Optional pipelineId_not_contains?: Maybe<string>

    pipelineId_not_contains

  • Optional pipelineId_not_ends_with?: Maybe<string>

    pipelineId_not_ends_with

  • Optional pipelineId_not_in?: Maybe<Array<string>>

    pipelineId_not_in

  • Optional pipelineId_not_starts_with?: Maybe<string>

    pipelineId_not_starts_with

  • Optional pipelineId_starts_with?: Maybe<string>

    pipelineId_starts_with

  • Optional provider?: Maybe<PipelineProvider>

    provider

  • Optional provider_in?: Maybe<Array<PipelineProvider>>

    provider_in

  • Optional provider_not?: Maybe<PipelineProvider>

    provider_not

  • Optional provider_not_in?: Maybe<Array<PipelineProvider>>

    provider_not_in

  • Optional push?: Maybe<_PushFilter>

    push

  • Optional push_in?: Maybe<_PushFilter>

    push_in

  • Optional push_not?: Maybe<_PushFilter>

    push_not

  • Optional push_not_in?: Maybe<_PushFilter>

    push_not_in

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional stages?: Maybe<_StageFilter>

    stages

  • Optional stages_every?: Maybe<_StageFilter>

    stages_every

  • Optional stages_in?: Maybe<_StageFilter>

    stages_in

  • Optional stages_none?: Maybe<_StageFilter>

    stages_none

  • Optional stages_not?: Maybe<_StageFilter>

    stages_not

  • Optional stages_not_in?: Maybe<_StageFilter>

    stages_not_in

  • Optional stages_single?: Maybe<_StageFilter>

    stages_single

  • Optional stages_some?: Maybe<_StageFilter>

    stages_some

  • Optional status?: Maybe<PipelineStatus>

    status

  • Optional status_in?: Maybe<Array<PipelineStatus>>

    status_in

  • Optional status_not?: Maybe<PipelineStatus>

    status_not

  • Optional status_not_in?: Maybe<Array<PipelineStatus>>

    status_not_in

_PullRequestFilter

_PullRequestFilter: object

Filter Input Type for PullRequest

Type declaration

  • Optional AND?: Maybe<Array<_PullRequestFilter>>

    AND

  • Optional OR?: Maybe<Array<_PullRequestFilter>>

    OR

  • Optional action?: Maybe<PullRequestAction>

    action

  • Optional action_in?: Maybe<Array<PullRequestAction>>

    action_in

  • Optional action_not?: Maybe<PullRequestAction>

    action_not

  • Optional action_not_in?: Maybe<Array<PullRequestAction>>

    action_not_in

  • Optional assignees?: Maybe<_ScmIdFilter>

    assignees

  • Optional assignees_every?: Maybe<_ScmIdFilter>

    assignees_every

  • Optional assignees_in?: Maybe<_ScmIdFilter>

    assignees_in

  • Optional assignees_none?: Maybe<_ScmIdFilter>

    assignees_none

  • Optional assignees_not?: Maybe<_ScmIdFilter>

    assignees_not

  • Optional assignees_not_in?: Maybe<_ScmIdFilter>

    assignees_not_in

  • Optional assignees_single?: Maybe<_ScmIdFilter>

    assignees_single

  • Optional assignees_some?: Maybe<_ScmIdFilter>

    assignees_some

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional author?: Maybe<_ScmIdFilter>

    author

  • Optional author_in?: Maybe<_ScmIdFilter>

    author_in

  • Optional author_not?: Maybe<_ScmIdFilter>

    author_not

  • Optional author_not_in?: Maybe<_ScmIdFilter>

    author_not_in

  • Optional base?: Maybe<_CommitFilter>

    base

  • Optional baseBranchName?: Maybe<string>

    baseBranchName

  • Optional baseBranchName_contains?: Maybe<string>

    baseBranchName_contains

  • Optional baseBranchName_ends_with?: Maybe<string>

    baseBranchName_ends_with

  • Optional baseBranchName_gt?: Maybe<string>

    baseBranchName_gt

  • Optional baseBranchName_gte?: Maybe<string>

    baseBranchName_gte

  • Optional baseBranchName_in?: Maybe<Array<string>>

    baseBranchName_in

  • Optional baseBranchName_lt?: Maybe<string>

    baseBranchName_lt

  • Optional baseBranchName_lte?: Maybe<string>

    baseBranchName_lte

  • Optional baseBranchName_not?: Maybe<string>

    baseBranchName_not

  • Optional baseBranchName_not_contains?: Maybe<string>

    baseBranchName_not_contains

  • Optional baseBranchName_not_ends_with?: Maybe<string>

    baseBranchName_not_ends_with

  • Optional baseBranchName_not_in?: Maybe<Array<string>>

    baseBranchName_not_in

  • Optional baseBranchName_not_starts_with?: Maybe<string>

    baseBranchName_not_starts_with

  • Optional baseBranchName_starts_with?: Maybe<string>

    baseBranchName_starts_with

  • Optional base_in?: Maybe<_CommitFilter>

    base_in

  • Optional base_not?: Maybe<_CommitFilter>

    base_not

  • Optional base_not_in?: Maybe<_CommitFilter>

    base_not_in

  • Optional body?: Maybe<string>

    body

  • Optional body_contains?: Maybe<string>

    body_contains

  • Optional body_ends_with?: Maybe<string>

    body_ends_with

  • Optional body_gt?: Maybe<string>

    body_gt

  • Optional body_gte?: Maybe<string>

    body_gte

  • Optional body_in?: Maybe<Array<string>>

    body_in

  • Optional body_lt?: Maybe<string>

    body_lt

  • Optional body_lte?: Maybe<string>

    body_lte

  • Optional body_not?: Maybe<string>

    body_not

  • Optional body_not_contains?: Maybe<string>

    body_not_contains

  • Optional body_not_ends_with?: Maybe<string>

    body_not_ends_with

  • Optional body_not_in?: Maybe<Array<string>>

    body_not_in

  • Optional body_not_starts_with?: Maybe<string>

    body_not_starts_with

  • Optional body_starts_with?: Maybe<string>

    body_starts_with

  • Optional branch?: Maybe<_BranchFilter>

    branch

  • Optional branchName?: Maybe<string>

    branchName

  • Optional branchName_contains?: Maybe<string>

    branchName_contains

  • Optional branchName_ends_with?: Maybe<string>

    branchName_ends_with

  • Optional branchName_gt?: Maybe<string>

    branchName_gt

  • Optional branchName_gte?: Maybe<string>

    branchName_gte

  • Optional branchName_in?: Maybe<Array<string>>

    branchName_in

  • Optional branchName_lt?: Maybe<string>

    branchName_lt

  • Optional branchName_lte?: Maybe<string>

    branchName_lte

  • Optional branchName_not?: Maybe<string>

    branchName_not

  • Optional branchName_not_contains?: Maybe<string>

    branchName_not_contains

  • Optional branchName_not_ends_with?: Maybe<string>

    branchName_not_ends_with

  • Optional branchName_not_in?: Maybe<Array<string>>

    branchName_not_in

  • Optional branchName_not_starts_with?: Maybe<string>

    branchName_not_starts_with

  • Optional branchName_starts_with?: Maybe<string>

    branchName_starts_with

  • Optional branch_in?: Maybe<_BranchFilter>

    branch_in

  • Optional branch_not?: Maybe<_BranchFilter>

    branch_not

  • Optional branch_not_in?: Maybe<_BranchFilter>

    branch_not_in

  • Optional builds?: Maybe<_BuildFilter>

    builds

  • Optional builds_every?: Maybe<_BuildFilter>

    builds_every

  • Optional builds_in?: Maybe<_BuildFilter>

    builds_in

  • Optional builds_none?: Maybe<_BuildFilter>

    builds_none

  • Optional builds_not?: Maybe<_BuildFilter>

    builds_not

  • Optional builds_not_in?: Maybe<_BuildFilter>

    builds_not_in

  • Optional builds_single?: Maybe<_BuildFilter>

    builds_single

  • Optional builds_some?: Maybe<_BuildFilter>

    builds_some

  • Optional closedAt?: Maybe<string>

    closedAt

  • Optional closedAt_contains?: Maybe<string>

    closedAt_contains

  • Optional closedAt_ends_with?: Maybe<string>

    closedAt_ends_with

  • Optional closedAt_gt?: Maybe<string>

    closedAt_gt

  • Optional closedAt_gte?: Maybe<string>

    closedAt_gte

  • Optional closedAt_in?: Maybe<Array<string>>

    closedAt_in

  • Optional closedAt_lt?: Maybe<string>

    closedAt_lt

  • Optional closedAt_lte?: Maybe<string>

    closedAt_lte

  • Optional closedAt_not?: Maybe<string>

    closedAt_not

  • Optional closedAt_not_contains?: Maybe<string>

    closedAt_not_contains

  • Optional closedAt_not_ends_with?: Maybe<string>

    closedAt_not_ends_with

  • Optional closedAt_not_in?: Maybe<Array<string>>

    closedAt_not_in

  • Optional closedAt_not_starts_with?: Maybe<string>

    closedAt_not_starts_with

  • Optional closedAt_starts_with?: Maybe<string>

    closedAt_starts_with

  • Optional comments?: Maybe<_CommentFilter>

    comments

  • Optional comments_every?: Maybe<_CommentFilter>

    comments_every

  • Optional comments_in?: Maybe<_CommentFilter>

    comments_in

  • Optional comments_none?: Maybe<_CommentFilter>

    comments_none

  • Optional comments_not?: Maybe<_CommentFilter>

    comments_not

  • Optional comments_not_in?: Maybe<_CommentFilter>

    comments_not_in

  • Optional comments_single?: Maybe<_CommentFilter>

    comments_single

  • Optional comments_some?: Maybe<_CommentFilter>

    comments_some

  • Optional commits?: Maybe<_CommitFilter>

    commits

  • Optional commits_every?: Maybe<_CommitFilter>

    commits_every

  • Optional commits_in?: Maybe<_CommitFilter>

    commits_in

  • Optional commits_none?: Maybe<_CommitFilter>

    commits_none

  • Optional commits_not?: Maybe<_CommitFilter>

    commits_not

  • Optional commits_not_in?: Maybe<_CommitFilter>

    commits_not_in

  • Optional commits_single?: Maybe<_CommitFilter>

    commits_single

  • Optional commits_some?: Maybe<_CommitFilter>

    commits_some

  • Optional createdAt?: Maybe<string>

    createdAt

  • Optional createdAt_contains?: Maybe<string>

    createdAt_contains

  • Optional createdAt_ends_with?: Maybe<string>

    createdAt_ends_with

  • Optional createdAt_gt?: Maybe<string>

    createdAt_gt

  • Optional createdAt_gte?: Maybe<string>

    createdAt_gte

  • Optional createdAt_in?: Maybe<Array<string>>

    createdAt_in

  • Optional createdAt_lt?: Maybe<string>

    createdAt_lt

  • Optional createdAt_lte?: Maybe<string>

    createdAt_lte

  • Optional createdAt_not?: Maybe<string>

    createdAt_not

  • Optional createdAt_not_contains?: Maybe<string>

    createdAt_not_contains

  • Optional createdAt_not_ends_with?: Maybe<string>

    createdAt_not_ends_with

  • Optional createdAt_not_in?: Maybe<Array<string>>

    createdAt_not_in

  • Optional createdAt_not_starts_with?: Maybe<string>

    createdAt_not_starts_with

  • Optional createdAt_starts_with?: Maybe<string>

    createdAt_starts_with

  • Optional destinationBranch?: Maybe<_BranchFilter>

    destinationBranch

  • Optional destinationBranch_in?: Maybe<_BranchFilter>

    destinationBranch_in

  • Optional destinationBranch_not?: Maybe<_BranchFilter>

    destinationBranch_not

  • Optional destinationBranch_not_in?: Maybe<_BranchFilter>

    destinationBranch_not_in

  • Optional head?: Maybe<_CommitFilter>

    head

  • Optional head_in?: Maybe<_CommitFilter>

    head_in

  • Optional head_not?: Maybe<_CommitFilter>

    head_not

  • Optional head_not_in?: Maybe<_CommitFilter>

    head_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional labels?: Maybe<_LabelFilter>

    labels

  • Optional labels_every?: Maybe<_LabelFilter>

    labels_every

  • Optional labels_in?: Maybe<_LabelFilter>

    labels_in

  • Optional labels_none?: Maybe<_LabelFilter>

    labels_none

  • Optional labels_not?: Maybe<_LabelFilter>

    labels_not

  • Optional labels_not_in?: Maybe<_LabelFilter>

    labels_not_in

  • Optional labels_single?: Maybe<_LabelFilter>

    labels_single

  • Optional labels_some?: Maybe<_LabelFilter>

    labels_some

  • Optional lastAssignedBy?: Maybe<_ScmIdFilter>

    lastAssignedBy

  • Optional lastAssignedBy_in?: Maybe<_ScmIdFilter>

    lastAssignedBy_in

  • Optional lastAssignedBy_not?: Maybe<_ScmIdFilter>

    lastAssignedBy_not

  • Optional lastAssignedBy_not_in?: Maybe<_ScmIdFilter>

    lastAssignedBy_not_in

  • Optional mergeCommit?: Maybe<_CommitFilter>

    mergeCommit

  • Optional mergeCommit_in?: Maybe<_CommitFilter>

    mergeCommit_in

  • Optional mergeCommit_not?: Maybe<_CommitFilter>

    mergeCommit_not

  • Optional mergeCommit_not_in?: Maybe<_CommitFilter>

    mergeCommit_not_in

  • Optional mergeStatus?: Maybe<MergeStatus>

    mergeStatus

  • Optional mergeStatus_in?: Maybe<Array<MergeStatus>>

    mergeStatus_in

  • Optional mergeStatus_not?: Maybe<MergeStatus>

    mergeStatus_not

  • Optional mergeStatus_not_in?: Maybe<Array<MergeStatus>>

    mergeStatus_not_in

  • Optional merged?: Maybe<boolean>

    merged

  • Optional mergedAt?: Maybe<string>

    mergedAt

  • Optional mergedAt_contains?: Maybe<string>

    mergedAt_contains

  • Optional mergedAt_ends_with?: Maybe<string>

    mergedAt_ends_with

  • Optional mergedAt_gt?: Maybe<string>

    mergedAt_gt

  • Optional mergedAt_gte?: Maybe<string>

    mergedAt_gte

  • Optional mergedAt_in?: Maybe<Array<string>>

    mergedAt_in

  • Optional mergedAt_lt?: Maybe<string>

    mergedAt_lt

  • Optional mergedAt_lte?: Maybe<string>

    mergedAt_lte

  • Optional mergedAt_not?: Maybe<string>

    mergedAt_not

  • Optional mergedAt_not_contains?: Maybe<string>

    mergedAt_not_contains

  • Optional mergedAt_not_ends_with?: Maybe<string>

    mergedAt_not_ends_with

  • Optional mergedAt_not_in?: Maybe<Array<string>>

    mergedAt_not_in

  • Optional mergedAt_not_starts_with?: Maybe<string>

    mergedAt_not_starts_with

  • Optional mergedAt_starts_with?: Maybe<string>

    mergedAt_starts_with

  • Optional merged_not?: Maybe<boolean>

    merged_not

  • Optional merger?: Maybe<_ScmIdFilter>

    merger

  • Optional merger_in?: Maybe<_ScmIdFilter>

    merger_in

  • Optional merger_not?: Maybe<_ScmIdFilter>

    merger_not

  • Optional merger_not_in?: Maybe<_ScmIdFilter>

    merger_not_in

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional number?: Maybe<number>

    number

  • Optional number_gt?: Maybe<number>

    number_gt

  • Optional number_gte?: Maybe<number>

    number_gte

  • Optional number_in?: Maybe<Array<number>>

    number_in

  • Optional number_lt?: Maybe<number>

    number_lt

  • Optional number_lte?: Maybe<number>

    number_lte

  • Optional number_not?: Maybe<number>

    number_not

  • Optional number_not_in?: Maybe<Array<number>>

    number_not_in

  • Optional prId?: Maybe<string>

    prId

  • Optional prId_contains?: Maybe<string>

    prId_contains

  • Optional prId_ends_with?: Maybe<string>

    prId_ends_with

  • Optional prId_gt?: Maybe<string>

    prId_gt

  • Optional prId_gte?: Maybe<string>

    prId_gte

  • Optional prId_in?: Maybe<Array<string>>

    prId_in

  • Optional prId_lt?: Maybe<string>

    prId_lt

  • Optional prId_lte?: Maybe<string>

    prId_lte

  • Optional prId_not?: Maybe<string>

    prId_not

  • Optional prId_not_contains?: Maybe<string>

    prId_not_contains

  • Optional prId_not_ends_with?: Maybe<string>

    prId_not_ends_with

  • Optional prId_not_in?: Maybe<Array<string>>

    prId_not_in

  • Optional prId_not_starts_with?: Maybe<string>

    prId_not_starts_with

  • Optional prId_starts_with?: Maybe<string>

    prId_starts_with

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional reviewers?: Maybe<_ScmIdFilter>

    reviewers

  • Optional reviewers_every?: Maybe<_ScmIdFilter>

    reviewers_every

  • Optional reviewers_in?: Maybe<_ScmIdFilter>

    reviewers_in

  • Optional reviewers_none?: Maybe<_ScmIdFilter>

    reviewers_none

  • Optional reviewers_not?: Maybe<_ScmIdFilter>

    reviewers_not

  • Optional reviewers_not_in?: Maybe<_ScmIdFilter>

    reviewers_not_in

  • Optional reviewers_single?: Maybe<_ScmIdFilter>

    reviewers_single

  • Optional reviewers_some?: Maybe<_ScmIdFilter>

    reviewers_some

  • Optional reviews?: Maybe<_ReviewFilter>

    reviews

  • Optional reviews_every?: Maybe<_ReviewFilter>

    reviews_every

  • Optional reviews_in?: Maybe<_ReviewFilter>

    reviews_in

  • Optional reviews_none?: Maybe<_ReviewFilter>

    reviews_none

  • Optional reviews_not?: Maybe<_ReviewFilter>

    reviews_not

  • Optional reviews_not_in?: Maybe<_ReviewFilter>

    reviews_not_in

  • Optional reviews_single?: Maybe<_ReviewFilter>

    reviews_single

  • Optional reviews_some?: Maybe<_ReviewFilter>

    reviews_some

  • Optional sourceBranch?: Maybe<_BranchFilter>

    sourceBranch

  • Optional sourceBranch_in?: Maybe<_BranchFilter>

    sourceBranch_in

  • Optional sourceBranch_not?: Maybe<_BranchFilter>

    sourceBranch_not

  • Optional sourceBranch_not_in?: Maybe<_BranchFilter>

    sourceBranch_not_in

  • Optional state?: Maybe<string>

    state

  • Optional state_contains?: Maybe<string>

    state_contains

  • Optional state_ends_with?: Maybe<string>

    state_ends_with

  • Optional state_gt?: Maybe<string>

    state_gt

  • Optional state_gte?: Maybe<string>

    state_gte

  • Optional state_in?: Maybe<Array<string>>

    state_in

  • Optional state_lt?: Maybe<string>

    state_lt

  • Optional state_lte?: Maybe<string>

    state_lte

  • Optional state_not?: Maybe<string>

    state_not

  • Optional state_not_contains?: Maybe<string>

    state_not_contains

  • Optional state_not_ends_with?: Maybe<string>

    state_not_ends_with

  • Optional state_not_in?: Maybe<Array<string>>

    state_not_in

  • Optional state_not_starts_with?: Maybe<string>

    state_not_starts_with

  • Optional state_starts_with?: Maybe<string>

    state_starts_with

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

  • Optional title?: Maybe<string>

    title

  • Optional title_contains?: Maybe<string>

    title_contains

  • Optional title_ends_with?: Maybe<string>

    title_ends_with

  • Optional title_gt?: Maybe<string>

    title_gt

  • Optional title_gte?: Maybe<string>

    title_gte

  • Optional title_in?: Maybe<Array<string>>

    title_in

  • Optional title_lt?: Maybe<string>

    title_lt

  • Optional title_lte?: Maybe<string>

    title_lte

  • Optional title_not?: Maybe<string>

    title_not

  • Optional title_not_contains?: Maybe<string>

    title_not_contains

  • Optional title_not_ends_with?: Maybe<string>

    title_not_ends_with

  • Optional title_not_in?: Maybe<Array<string>>

    title_not_in

  • Optional title_not_starts_with?: Maybe<string>

    title_not_starts_with

  • Optional title_starts_with?: Maybe<string>

    title_starts_with

  • Optional updatedAt?: Maybe<string>

    updatedAt

  • Optional updatedAt_contains?: Maybe<string>

    updatedAt_contains

  • Optional updatedAt_ends_with?: Maybe<string>

    updatedAt_ends_with

  • Optional updatedAt_gt?: Maybe<string>

    updatedAt_gt

  • Optional updatedAt_gte?: Maybe<string>

    updatedAt_gte

  • Optional updatedAt_in?: Maybe<Array<string>>

    updatedAt_in

  • Optional updatedAt_lt?: Maybe<string>

    updatedAt_lt

  • Optional updatedAt_lte?: Maybe<string>

    updatedAt_lte

  • Optional updatedAt_not?: Maybe<string>

    updatedAt_not

  • Optional updatedAt_not_contains?: Maybe<string>

    updatedAt_not_contains

  • Optional updatedAt_not_ends_with?: Maybe<string>

    updatedAt_not_ends_with

  • Optional updatedAt_not_in?: Maybe<Array<string>>

    updatedAt_not_in

  • Optional updatedAt_not_starts_with?: Maybe<string>

    updatedAt_not_starts_with

  • Optional updatedAt_starts_with?: Maybe<string>

    updatedAt_starts_with

_PullRequestImpactFilter

_PullRequestImpactFilter: object

Filter Input Type for PullRequestImpact

Type declaration

  • Optional AND?: Maybe<Array<_PullRequestImpactFilter>>

    AND

  • Optional OR?: Maybe<Array<_PullRequestImpactFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional data?: Maybe<string>

    data

  • Optional data_contains?: Maybe<string>

    data_contains

  • Optional data_ends_with?: Maybe<string>

    data_ends_with

  • Optional data_gt?: Maybe<string>

    data_gt

  • Optional data_gte?: Maybe<string>

    data_gte

  • Optional data_in?: Maybe<Array<string>>

    data_in

  • Optional data_lt?: Maybe<string>

    data_lt

  • Optional data_lte?: Maybe<string>

    data_lte

  • Optional data_not?: Maybe<string>

    data_not

  • Optional data_not_contains?: Maybe<string>

    data_not_contains

  • Optional data_not_ends_with?: Maybe<string>

    data_not_ends_with

  • Optional data_not_in?: Maybe<Array<string>>

    data_not_in

  • Optional data_not_starts_with?: Maybe<string>

    data_not_starts_with

  • Optional data_starts_with?: Maybe<string>

    data_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional pullRequest?: Maybe<_PullRequestFilter>

    pullRequest

  • Optional pullRequest_in?: Maybe<_PullRequestFilter>

    pullRequest_in

  • Optional pullRequest_not?: Maybe<_PullRequestFilter>

    pullRequest_not

  • Optional pullRequest_not_in?: Maybe<_PullRequestFilter>

    pullRequest_not_in

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

_PushFilter

_PushFilter: object

Filter Input Type for Push

Type declaration

  • Optional AND?: Maybe<Array<_PushFilter>>

    AND

  • Optional OR?: Maybe<Array<_PushFilter>>

    OR

  • Optional after?: Maybe<_CommitFilter>

    after

  • Optional after_in?: Maybe<_CommitFilter>

    after_in

  • Optional after_not?: Maybe<_CommitFilter>

    after_not

  • Optional after_not_in?: Maybe<_CommitFilter>

    after_not_in

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional before?: Maybe<_CommitFilter>

    before

  • Optional before_in?: Maybe<_CommitFilter>

    before_in

  • Optional before_not?: Maybe<_CommitFilter>

    before_not

  • Optional before_not_in?: Maybe<_CommitFilter>

    before_not_in

  • Optional branch?: Maybe<string>

    branch

  • Optional branch_contains?: Maybe<string>

    branch_contains

  • Optional branch_ends_with?: Maybe<string>

    branch_ends_with

  • Optional branch_gt?: Maybe<string>

    branch_gt

  • Optional branch_gte?: Maybe<string>

    branch_gte

  • Optional branch_in?: Maybe<Array<string>>

    branch_in

  • Optional branch_lt?: Maybe<string>

    branch_lt

  • Optional branch_lte?: Maybe<string>

    branch_lte

  • Optional branch_not?: Maybe<string>

    branch_not

  • Optional branch_not_contains?: Maybe<string>

    branch_not_contains

  • Optional branch_not_ends_with?: Maybe<string>

    branch_not_ends_with

  • Optional branch_not_in?: Maybe<Array<string>>

    branch_not_in

  • Optional branch_not_starts_with?: Maybe<string>

    branch_not_starts_with

  • Optional branch_starts_with?: Maybe<string>

    branch_starts_with

  • Optional builds?: Maybe<_BuildFilter>

    builds

  • Optional builds_every?: Maybe<_BuildFilter>

    builds_every

  • Optional builds_in?: Maybe<_BuildFilter>

    builds_in

  • Optional builds_none?: Maybe<_BuildFilter>

    builds_none

  • Optional builds_not?: Maybe<_BuildFilter>

    builds_not

  • Optional builds_not_in?: Maybe<_BuildFilter>

    builds_not_in

  • Optional builds_single?: Maybe<_BuildFilter>

    builds_single

  • Optional builds_some?: Maybe<_BuildFilter>

    builds_some

  • Optional commits?: Maybe<_CommitFilter>

    commits

  • Optional commits_every?: Maybe<_CommitFilter>

    commits_every

  • Optional commits_in?: Maybe<_CommitFilter>

    commits_in

  • Optional commits_none?: Maybe<_CommitFilter>

    commits_none

  • Optional commits_not?: Maybe<_CommitFilter>

    commits_not

  • Optional commits_not_in?: Maybe<_CommitFilter>

    commits_not_in

  • Optional commits_single?: Maybe<_CommitFilter>

    commits_single

  • Optional commits_some?: Maybe<_CommitFilter>

    commits_some

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional pipelines?: Maybe<_PipelineFilter>

    pipelines

  • Optional pipelines_every?: Maybe<_PipelineFilter>

    pipelines_every

  • Optional pipelines_in?: Maybe<_PipelineFilter>

    pipelines_in

  • Optional pipelines_none?: Maybe<_PipelineFilter>

    pipelines_none

  • Optional pipelines_not?: Maybe<_PipelineFilter>

    pipelines_not

  • Optional pipelines_not_in?: Maybe<_PipelineFilter>

    pipelines_not_in

  • Optional pipelines_single?: Maybe<_PipelineFilter>

    pipelines_single

  • Optional pipelines_some?: Maybe<_PipelineFilter>

    pipelines_some

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_PushImpactFilter

_PushImpactFilter: object

Filter Input Type for PushImpact

Type declaration

  • Optional AND?: Maybe<Array<_PushImpactFilter>>

    AND

  • Optional OR?: Maybe<Array<_PushImpactFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional data?: Maybe<string>

    data

  • Optional data_contains?: Maybe<string>

    data_contains

  • Optional data_ends_with?: Maybe<string>

    data_ends_with

  • Optional data_gt?: Maybe<string>

    data_gt

  • Optional data_gte?: Maybe<string>

    data_gte

  • Optional data_in?: Maybe<Array<string>>

    data_in

  • Optional data_lt?: Maybe<string>

    data_lt

  • Optional data_lte?: Maybe<string>

    data_lte

  • Optional data_not?: Maybe<string>

    data_not

  • Optional data_not_contains?: Maybe<string>

    data_not_contains

  • Optional data_not_ends_with?: Maybe<string>

    data_not_ends_with

  • Optional data_not_in?: Maybe<Array<string>>

    data_not_in

  • Optional data_not_starts_with?: Maybe<string>

    data_not_starts_with

  • Optional data_starts_with?: Maybe<string>

    data_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional push?: Maybe<_PushFilter>

    push

  • Optional push_in?: Maybe<_PushFilter>

    push_in

  • Optional push_not?: Maybe<_PushFilter>

    push_not

  • Optional push_not_in?: Maybe<_PushFilter>

    push_not_in

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

_ReleaseFilter

_ReleaseFilter: object

Filter Input Type for Release

Type declaration

  • Optional AND?: Maybe<Array<_ReleaseFilter>>

    AND

  • Optional OR?: Maybe<Array<_ReleaseFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional tag?: Maybe<_TagFilter>

    tag

  • Optional tag_in?: Maybe<_TagFilter>

    tag_in

  • Optional tag_not?: Maybe<_TagFilter>

    tag_not

  • Optional tag_not_in?: Maybe<_TagFilter>

    tag_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_RepoFilter

_RepoFilter: object

Filter Input Type for Repo

Type declaration

  • Optional AND?: Maybe<Array<_RepoFilter>>

    AND

  • Optional OR?: Maybe<Array<_RepoFilter>>

    OR

  • Optional allowMergeCommit?: Maybe<boolean>

    allowMergeCommit

  • Optional allowMergeCommit_not?: Maybe<boolean>

    allowMergeCommit_not

  • Optional allowRebaseMerge?: Maybe<boolean>

    allowRebaseMerge

  • Optional allowRebaseMerge_not?: Maybe<boolean>

    allowRebaseMerge_not

  • Optional allowSquashMerge?: Maybe<boolean>

    allowSquashMerge

  • Optional allowSquashMerge_not?: Maybe<boolean>

    allowSquashMerge_not

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional branches?: Maybe<_BranchFilter>

    branches

  • Optional branches_every?: Maybe<_BranchFilter>

    branches_every

  • Optional branches_in?: Maybe<_BranchFilter>

    branches_in

  • Optional branches_none?: Maybe<_BranchFilter>

    branches_none

  • Optional branches_not?: Maybe<_BranchFilter>

    branches_not

  • Optional branches_not_in?: Maybe<_BranchFilter>

    branches_not_in

  • Optional branches_single?: Maybe<_BranchFilter>

    branches_single

  • Optional branches_some?: Maybe<_BranchFilter>

    branches_some

  • Optional channels?: Maybe<_ChatChannelFilter>

    channels

  • Optional channels_every?: Maybe<_ChatChannelFilter>

    channels_every

  • Optional channels_in?: Maybe<_ChatChannelFilter>

    channels_in

  • Optional channels_none?: Maybe<_ChatChannelFilter>

    channels_none

  • Optional channels_not?: Maybe<_ChatChannelFilter>

    channels_not

  • Optional channels_not_in?: Maybe<_ChatChannelFilter>

    channels_not_in

  • Optional channels_single?: Maybe<_ChatChannelFilter>

    channels_single

  • Optional channels_some?: Maybe<_ChatChannelFilter>

    channels_some

  • Optional defaultBranch?: Maybe<string>

    defaultBranch

  • Optional defaultBranch_contains?: Maybe<string>

    defaultBranch_contains

  • Optional defaultBranch_ends_with?: Maybe<string>

    defaultBranch_ends_with

  • Optional defaultBranch_gt?: Maybe<string>

    defaultBranch_gt

  • Optional defaultBranch_gte?: Maybe<string>

    defaultBranch_gte

  • Optional defaultBranch_in?: Maybe<Array<string>>

    defaultBranch_in

  • Optional defaultBranch_lt?: Maybe<string>

    defaultBranch_lt

  • Optional defaultBranch_lte?: Maybe<string>

    defaultBranch_lte

  • Optional defaultBranch_not?: Maybe<string>

    defaultBranch_not

  • Optional defaultBranch_not_contains?: Maybe<string>

    defaultBranch_not_contains

  • Optional defaultBranch_not_ends_with?: Maybe<string>

    defaultBranch_not_ends_with

  • Optional defaultBranch_not_in?: Maybe<Array<string>>

    defaultBranch_not_in

  • Optional defaultBranch_not_starts_with?: Maybe<string>

    defaultBranch_not_starts_with

  • Optional defaultBranch_starts_with?: Maybe<string>

    defaultBranch_starts_with

  • Optional gitHubId?: Maybe<string>

    gitHubId

  • Optional gitHubId_contains?: Maybe<string>

    gitHubId_contains

  • Optional gitHubId_ends_with?: Maybe<string>

    gitHubId_ends_with

  • Optional gitHubId_gt?: Maybe<string>

    gitHubId_gt

  • Optional gitHubId_gte?: Maybe<string>

    gitHubId_gte

  • Optional gitHubId_in?: Maybe<Array<string>>

    gitHubId_in

  • Optional gitHubId_lt?: Maybe<string>

    gitHubId_lt

  • Optional gitHubId_lte?: Maybe<string>

    gitHubId_lte

  • Optional gitHubId_not?: Maybe<string>

    gitHubId_not

  • Optional gitHubId_not_contains?: Maybe<string>

    gitHubId_not_contains

  • Optional gitHubId_not_ends_with?: Maybe<string>

    gitHubId_not_ends_with

  • Optional gitHubId_not_in?: Maybe<Array<string>>

    gitHubId_not_in

  • Optional gitHubId_not_starts_with?: Maybe<string>

    gitHubId_not_starts_with

  • Optional gitHubId_starts_with?: Maybe<string>

    gitHubId_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional issue?: Maybe<_IssueFilter>

    issue

  • Optional issue_every?: Maybe<_IssueFilter>

    issue_every

  • Optional issue_in?: Maybe<_IssueFilter>

    issue_in

  • Optional issue_none?: Maybe<_IssueFilter>

    issue_none

  • Optional issue_not?: Maybe<_IssueFilter>

    issue_not

  • Optional issue_not_in?: Maybe<_IssueFilter>

    issue_not_in

  • Optional issue_single?: Maybe<_IssueFilter>

    issue_single

  • Optional issue_some?: Maybe<_IssueFilter>

    issue_some

  • Optional issues?: Maybe<_IssueFilter>

    issues

  • Optional issues_every?: Maybe<_IssueFilter>

    issues_every

  • Optional issues_in?: Maybe<_IssueFilter>

    issues_in

  • Optional issues_none?: Maybe<_IssueFilter>

    issues_none

  • Optional issues_not?: Maybe<_IssueFilter>

    issues_not

  • Optional issues_not_in?: Maybe<_IssueFilter>

    issues_not_in

  • Optional issues_single?: Maybe<_IssueFilter>

    issues_single

  • Optional issues_some?: Maybe<_IssueFilter>

    issues_some

  • Optional labels?: Maybe<_LabelFilter>

    labels

  • Optional labels_every?: Maybe<_LabelFilter>

    labels_every

  • Optional labels_in?: Maybe<_LabelFilter>

    labels_in

  • Optional labels_none?: Maybe<_LabelFilter>

    labels_none

  • Optional labels_not?: Maybe<_LabelFilter>

    labels_not

  • Optional labels_not_in?: Maybe<_LabelFilter>

    labels_not_in

  • Optional labels_single?: Maybe<_LabelFilter>

    labels_single

  • Optional labels_some?: Maybe<_LabelFilter>

    labels_some

  • Optional links?: Maybe<_ChannelLinkFilter>

    links

  • Optional links_every?: Maybe<_ChannelLinkFilter>

    links_every

  • Optional links_in?: Maybe<_ChannelLinkFilter>

    links_in

  • Optional links_none?: Maybe<_ChannelLinkFilter>

    links_none

  • Optional links_not?: Maybe<_ChannelLinkFilter>

    links_not

  • Optional links_not_in?: Maybe<_ChannelLinkFilter>

    links_not_in

  • Optional links_single?: Maybe<_ChannelLinkFilter>

    links_single

  • Optional links_some?: Maybe<_ChannelLinkFilter>

    links_some

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional org?: Maybe<_OrgFilter>

    org

  • Optional org_in?: Maybe<_OrgFilter>

    org_in

  • Optional org_not?: Maybe<_OrgFilter>

    org_not

  • Optional org_not_in?: Maybe<_OrgFilter>

    org_not_in

  • Optional owner?: Maybe<string>

    owner

  • Optional owner_contains?: Maybe<string>

    owner_contains

  • Optional owner_ends_with?: Maybe<string>

    owner_ends_with

  • Optional owner_gt?: Maybe<string>

    owner_gt

  • Optional owner_gte?: Maybe<string>

    owner_gte

  • Optional owner_in?: Maybe<Array<string>>

    owner_in

  • Optional owner_lt?: Maybe<string>

    owner_lt

  • Optional owner_lte?: Maybe<string>

    owner_lte

  • Optional owner_not?: Maybe<string>

    owner_not

  • Optional owner_not_contains?: Maybe<string>

    owner_not_contains

  • Optional owner_not_ends_with?: Maybe<string>

    owner_not_ends_with

  • Optional owner_not_in?: Maybe<Array<string>>

    owner_not_in

  • Optional owner_not_starts_with?: Maybe<string>

    owner_not_starts_with

  • Optional owner_starts_with?: Maybe<string>

    owner_starts_with

  • Optional pullRequest?: Maybe<_PullRequestFilter>

    pullRequest

  • Optional pullRequest_every?: Maybe<_PullRequestFilter>

    pullRequest_every

  • Optional pullRequest_in?: Maybe<_PullRequestFilter>

    pullRequest_in

  • Optional pullRequest_none?: Maybe<_PullRequestFilter>

    pullRequest_none

  • Optional pullRequest_not?: Maybe<_PullRequestFilter>

    pullRequest_not

  • Optional pullRequest_not_in?: Maybe<_PullRequestFilter>

    pullRequest_not_in

  • Optional pullRequest_single?: Maybe<_PullRequestFilter>

    pullRequest_single

  • Optional pullRequest_some?: Maybe<_PullRequestFilter>

    pullRequest_some

  • Optional pullRequests?: Maybe<_PullRequestFilter>

    pullRequests

  • Optional pullRequests_every?: Maybe<_PullRequestFilter>

    pullRequests_every

  • Optional pullRequests_in?: Maybe<_PullRequestFilter>

    pullRequests_in

  • Optional pullRequests_none?: Maybe<_PullRequestFilter>

    pullRequests_none

  • Optional pullRequests_not?: Maybe<_PullRequestFilter>

    pullRequests_not

  • Optional pullRequests_not_in?: Maybe<_PullRequestFilter>

    pullRequests_not_in

  • Optional pullRequests_single?: Maybe<_PullRequestFilter>

    pullRequests_single

  • Optional pullRequests_some?: Maybe<_PullRequestFilter>

    pullRequests_some

  • Optional repoId?: Maybe<string>

    repoId

  • Optional repoId_contains?: Maybe<string>

    repoId_contains

  • Optional repoId_ends_with?: Maybe<string>

    repoId_ends_with

  • Optional repoId_gt?: Maybe<string>

    repoId_gt

  • Optional repoId_gte?: Maybe<string>

    repoId_gte

  • Optional repoId_in?: Maybe<Array<string>>

    repoId_in

  • Optional repoId_lt?: Maybe<string>

    repoId_lt

  • Optional repoId_lte?: Maybe<string>

    repoId_lte

  • Optional repoId_not?: Maybe<string>

    repoId_not

  • Optional repoId_not_contains?: Maybe<string>

    repoId_not_contains

  • Optional repoId_not_ends_with?: Maybe<string>

    repoId_not_ends_with

  • Optional repoId_not_in?: Maybe<Array<string>>

    repoId_not_in

  • Optional repoId_not_starts_with?: Maybe<string>

    repoId_not_starts_with

  • Optional repoId_starts_with?: Maybe<string>

    repoId_starts_with

  • Optional webhook?: Maybe<_WebhookFilter>

    webhook

  • Optional webhook_in?: Maybe<_WebhookFilter>

    webhook_in

  • Optional webhook_not?: Maybe<_WebhookFilter>

    webhook_not

  • Optional webhook_not_in?: Maybe<_WebhookFilter>

    webhook_not_in

_ReviewFilter

_ReviewFilter: object

Filter Input Type for Review

Type declaration

  • Optional AND?: Maybe<Array<_ReviewFilter>>

    AND

  • Optional OR?: Maybe<Array<_ReviewFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional body?: Maybe<string>

    body

  • Optional body_contains?: Maybe<string>

    body_contains

  • Optional body_ends_with?: Maybe<string>

    body_ends_with

  • Optional body_gt?: Maybe<string>

    body_gt

  • Optional body_gte?: Maybe<string>

    body_gte

  • Optional body_in?: Maybe<Array<string>>

    body_in

  • Optional body_lt?: Maybe<string>

    body_lt

  • Optional body_lte?: Maybe<string>

    body_lte

  • Optional body_not?: Maybe<string>

    body_not

  • Optional body_not_contains?: Maybe<string>

    body_not_contains

  • Optional body_not_ends_with?: Maybe<string>

    body_not_ends_with

  • Optional body_not_in?: Maybe<Array<string>>

    body_not_in

  • Optional body_not_starts_with?: Maybe<string>

    body_not_starts_with

  • Optional body_starts_with?: Maybe<string>

    body_starts_with

  • Optional by?: Maybe<_ScmIdFilter>

    by

  • Optional by_every?: Maybe<_ScmIdFilter>

    by_every

  • Optional by_in?: Maybe<_ScmIdFilter>

    by_in

  • Optional by_none?: Maybe<_ScmIdFilter>

    by_none

  • Optional by_not?: Maybe<_ScmIdFilter>

    by_not

  • Optional by_not_in?: Maybe<_ScmIdFilter>

    by_not_in

  • Optional by_single?: Maybe<_ScmIdFilter>

    by_single

  • Optional by_some?: Maybe<_ScmIdFilter>

    by_some

  • Optional comments?: Maybe<_CommentFilter>

    comments

  • Optional comments_every?: Maybe<_CommentFilter>

    comments_every

  • Optional comments_in?: Maybe<_CommentFilter>

    comments_in

  • Optional comments_none?: Maybe<_CommentFilter>

    comments_none

  • Optional comments_not?: Maybe<_CommentFilter>

    comments_not

  • Optional comments_not_in?: Maybe<_CommentFilter>

    comments_not_in

  • Optional comments_single?: Maybe<_CommentFilter>

    comments_single

  • Optional comments_some?: Maybe<_CommentFilter>

    comments_some

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional gitHubId?: Maybe<string>

    gitHubId

  • Optional gitHubId_contains?: Maybe<string>

    gitHubId_contains

  • Optional gitHubId_ends_with?: Maybe<string>

    gitHubId_ends_with

  • Optional gitHubId_gt?: Maybe<string>

    gitHubId_gt

  • Optional gitHubId_gte?: Maybe<string>

    gitHubId_gte

  • Optional gitHubId_in?: Maybe<Array<string>>

    gitHubId_in

  • Optional gitHubId_lt?: Maybe<string>

    gitHubId_lt

  • Optional gitHubId_lte?: Maybe<string>

    gitHubId_lte

  • Optional gitHubId_not?: Maybe<string>

    gitHubId_not

  • Optional gitHubId_not_contains?: Maybe<string>

    gitHubId_not_contains

  • Optional gitHubId_not_ends_with?: Maybe<string>

    gitHubId_not_ends_with

  • Optional gitHubId_not_in?: Maybe<Array<string>>

    gitHubId_not_in

  • Optional gitHubId_not_starts_with?: Maybe<string>

    gitHubId_not_starts_with

  • Optional gitHubId_starts_with?: Maybe<string>

    gitHubId_starts_with

  • Optional htmlUrl?: Maybe<string>

    htmlUrl

  • Optional htmlUrl_contains?: Maybe<string>

    htmlUrl_contains

  • Optional htmlUrl_ends_with?: Maybe<string>

    htmlUrl_ends_with

  • Optional htmlUrl_gt?: Maybe<string>

    htmlUrl_gt

  • Optional htmlUrl_gte?: Maybe<string>

    htmlUrl_gte

  • Optional htmlUrl_in?: Maybe<Array<string>>

    htmlUrl_in

  • Optional htmlUrl_lt?: Maybe<string>

    htmlUrl_lt

  • Optional htmlUrl_lte?: Maybe<string>

    htmlUrl_lte

  • Optional htmlUrl_not?: Maybe<string>

    htmlUrl_not

  • Optional htmlUrl_not_contains?: Maybe<string>

    htmlUrl_not_contains

  • Optional htmlUrl_not_ends_with?: Maybe<string>

    htmlUrl_not_ends_with

  • Optional htmlUrl_not_in?: Maybe<Array<string>>

    htmlUrl_not_in

  • Optional htmlUrl_not_starts_with?: Maybe<string>

    htmlUrl_not_starts_with

  • Optional htmlUrl_starts_with?: Maybe<string>

    htmlUrl_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional pullRequest?: Maybe<_PullRequestFilter>

    pullRequest

  • Optional pullRequest_in?: Maybe<_PullRequestFilter>

    pullRequest_in

  • Optional pullRequest_not?: Maybe<_PullRequestFilter>

    pullRequest_not

  • Optional pullRequest_not_in?: Maybe<_PullRequestFilter>

    pullRequest_not_in

  • Optional reviewId?: Maybe<string>

    reviewId

  • Optional reviewId_contains?: Maybe<string>

    reviewId_contains

  • Optional reviewId_ends_with?: Maybe<string>

    reviewId_ends_with

  • Optional reviewId_gt?: Maybe<string>

    reviewId_gt

  • Optional reviewId_gte?: Maybe<string>

    reviewId_gte

  • Optional reviewId_in?: Maybe<Array<string>>

    reviewId_in

  • Optional reviewId_lt?: Maybe<string>

    reviewId_lt

  • Optional reviewId_lte?: Maybe<string>

    reviewId_lte

  • Optional reviewId_not?: Maybe<string>

    reviewId_not

  • Optional reviewId_not_contains?: Maybe<string>

    reviewId_not_contains

  • Optional reviewId_not_ends_with?: Maybe<string>

    reviewId_not_ends_with

  • Optional reviewId_not_in?: Maybe<Array<string>>

    reviewId_not_in

  • Optional reviewId_not_starts_with?: Maybe<string>

    reviewId_not_starts_with

  • Optional reviewId_starts_with?: Maybe<string>

    reviewId_starts_with

  • Optional state?: Maybe<ReviewState>

    state

  • Optional state_in?: Maybe<Array<ReviewState>>

    state_in

  • Optional state_not?: Maybe<ReviewState>

    state_not

  • Optional state_not_in?: Maybe<Array<ReviewState>>

    state_not_in

  • Optional submittedAt?: Maybe<string>

    submittedAt

  • Optional submittedAt_contains?: Maybe<string>

    submittedAt_contains

  • Optional submittedAt_ends_with?: Maybe<string>

    submittedAt_ends_with

  • Optional submittedAt_gt?: Maybe<string>

    submittedAt_gt

  • Optional submittedAt_gte?: Maybe<string>

    submittedAt_gte

  • Optional submittedAt_in?: Maybe<Array<string>>

    submittedAt_in

  • Optional submittedAt_lt?: Maybe<string>

    submittedAt_lt

  • Optional submittedAt_lte?: Maybe<string>

    submittedAt_lte

  • Optional submittedAt_not?: Maybe<string>

    submittedAt_not

  • Optional submittedAt_not_contains?: Maybe<string>

    submittedAt_not_contains

  • Optional submittedAt_not_ends_with?: Maybe<string>

    submittedAt_not_ends_with

  • Optional submittedAt_not_in?: Maybe<Array<string>>

    submittedAt_not_in

  • Optional submittedAt_not_starts_with?: Maybe<string>

    submittedAt_not_starts_with

  • Optional submittedAt_starts_with?: Maybe<string>

    submittedAt_starts_with

_ScmIdFilter

_ScmIdFilter: object

Filter Input Type for SCMId

Type declaration

  • Optional AND?: Maybe<Array<_ScmIdFilter>>

    AND

  • Optional OR?: Maybe<Array<_ScmIdFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional avatar?: Maybe<string>

    avatar

  • Optional avatar_contains?: Maybe<string>

    avatar_contains

  • Optional avatar_ends_with?: Maybe<string>

    avatar_ends_with

  • Optional avatar_gt?: Maybe<string>

    avatar_gt

  • Optional avatar_gte?: Maybe<string>

    avatar_gte

  • Optional avatar_in?: Maybe<Array<string>>

    avatar_in

  • Optional avatar_lt?: Maybe<string>

    avatar_lt

  • Optional avatar_lte?: Maybe<string>

    avatar_lte

  • Optional avatar_not?: Maybe<string>

    avatar_not

  • Optional avatar_not_contains?: Maybe<string>

    avatar_not_contains

  • Optional avatar_not_ends_with?: Maybe<string>

    avatar_not_ends_with

  • Optional avatar_not_in?: Maybe<Array<string>>

    avatar_not_in

  • Optional avatar_not_starts_with?: Maybe<string>

    avatar_not_starts_with

  • Optional avatar_starts_with?: Maybe<string>

    avatar_starts_with

  • Optional emails?: Maybe<_EmailFilter>

    emails

  • Optional emails_every?: Maybe<_EmailFilter>

    emails_every

  • Optional emails_in?: Maybe<_EmailFilter>

    emails_in

  • Optional emails_none?: Maybe<_EmailFilter>

    emails_none

  • Optional emails_not?: Maybe<_EmailFilter>

    emails_not

  • Optional emails_not_in?: Maybe<_EmailFilter>

    emails_not_in

  • Optional emails_single?: Maybe<_EmailFilter>

    emails_single

  • Optional emails_some?: Maybe<_EmailFilter>

    emails_some

  • Optional login?: Maybe<string>

    login

  • Optional login_contains?: Maybe<string>

    login_contains

  • Optional login_ends_with?: Maybe<string>

    login_ends_with

  • Optional login_gt?: Maybe<string>

    login_gt

  • Optional login_gte?: Maybe<string>

    login_gte

  • Optional login_in?: Maybe<Array<string>>

    login_in

  • Optional login_lt?: Maybe<string>

    login_lt

  • Optional login_lte?: Maybe<string>

    login_lte

  • Optional login_not?: Maybe<string>

    login_not

  • Optional login_not_contains?: Maybe<string>

    login_not_contains

  • Optional login_not_ends_with?: Maybe<string>

    login_not_ends_with

  • Optional login_not_in?: Maybe<Array<string>>

    login_not_in

  • Optional login_not_starts_with?: Maybe<string>

    login_not_starts_with

  • Optional login_starts_with?: Maybe<string>

    login_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional person?: Maybe<_PersonFilter>

    person

  • Optional person_in?: Maybe<_PersonFilter>

    person_in

  • Optional person_not?: Maybe<_PersonFilter>

    person_not

  • Optional person_not_in?: Maybe<_PersonFilter>

    person_not_in

  • Optional provider?: Maybe<_GitHubProviderFilter>

    provider

  • Optional provider_every?: Maybe<_GitHubProviderFilter>

    provider_every

  • Optional provider_in?: Maybe<_GitHubProviderFilter>

    provider_in

  • Optional provider_none?: Maybe<_GitHubProviderFilter>

    provider_none

  • Optional provider_not?: Maybe<_GitHubProviderFilter>

    provider_not

  • Optional provider_not_in?: Maybe<_GitHubProviderFilter>

    provider_not_in

  • Optional provider_single?: Maybe<_GitHubProviderFilter>

    provider_single

  • Optional provider_some?: Maybe<_GitHubProviderFilter>

    provider_some

  • Optional scmProvider?: Maybe<_ScmProviderFilter>

    scmProvider

  • Optional scmProvider_in?: Maybe<_ScmProviderFilter>

    scmProvider_in

  • Optional scmProvider_not?: Maybe<_ScmProviderFilter>

    scmProvider_not

  • Optional scmProvider_not_in?: Maybe<_ScmProviderFilter>

    scmProvider_not_in

_ScmProviderFilter

_ScmProviderFilter: object

Filter Input Type for SCMProvider

Type declaration

  • Optional AND?: Maybe<Array<_ScmProviderFilter>>

    AND

  • Optional OR?: Maybe<Array<_ScmProviderFilter>>

    OR

  • Optional apiUrl?: Maybe<string>

    apiUrl

  • Optional apiUrl_contains?: Maybe<string>

    apiUrl_contains

  • Optional apiUrl_ends_with?: Maybe<string>

    apiUrl_ends_with

  • Optional apiUrl_gt?: Maybe<string>

    apiUrl_gt

  • Optional apiUrl_gte?: Maybe<string>

    apiUrl_gte

  • Optional apiUrl_in?: Maybe<Array<string>>

    apiUrl_in

  • Optional apiUrl_lt?: Maybe<string>

    apiUrl_lt

  • Optional apiUrl_lte?: Maybe<string>

    apiUrl_lte

  • Optional apiUrl_not?: Maybe<string>

    apiUrl_not

  • Optional apiUrl_not_contains?: Maybe<string>

    apiUrl_not_contains

  • Optional apiUrl_not_ends_with?: Maybe<string>

    apiUrl_not_ends_with

  • Optional apiUrl_not_in?: Maybe<Array<string>>

    apiUrl_not_in

  • Optional apiUrl_not_starts_with?: Maybe<string>

    apiUrl_not_starts_with

  • Optional apiUrl_starts_with?: Maybe<string>

    apiUrl_starts_with

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional gitUrl?: Maybe<string>

    gitUrl

  • Optional gitUrl_contains?: Maybe<string>

    gitUrl_contains

  • Optional gitUrl_ends_with?: Maybe<string>

    gitUrl_ends_with

  • Optional gitUrl_gt?: Maybe<string>

    gitUrl_gt

  • Optional gitUrl_gte?: Maybe<string>

    gitUrl_gte

  • Optional gitUrl_in?: Maybe<Array<string>>

    gitUrl_in

  • Optional gitUrl_lt?: Maybe<string>

    gitUrl_lt

  • Optional gitUrl_lte?: Maybe<string>

    gitUrl_lte

  • Optional gitUrl_not?: Maybe<string>

    gitUrl_not

  • Optional gitUrl_not_contains?: Maybe<string>

    gitUrl_not_contains

  • Optional gitUrl_not_ends_with?: Maybe<string>

    gitUrl_not_ends_with

  • Optional gitUrl_not_in?: Maybe<Array<string>>

    gitUrl_not_in

  • Optional gitUrl_not_starts_with?: Maybe<string>

    gitUrl_not_starts_with

  • Optional gitUrl_starts_with?: Maybe<string>

    gitUrl_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional private?: Maybe<boolean>

    private

  • Optional private_not?: Maybe<boolean>

    private_not

  • Optional providerId?: Maybe<string>

    providerId

  • Optional providerId_contains?: Maybe<string>

    providerId_contains

  • Optional providerId_ends_with?: Maybe<string>

    providerId_ends_with

  • Optional providerId_gt?: Maybe<string>

    providerId_gt

  • Optional providerId_gte?: Maybe<string>

    providerId_gte

  • Optional providerId_in?: Maybe<Array<string>>

    providerId_in

  • Optional providerId_lt?: Maybe<string>

    providerId_lt

  • Optional providerId_lte?: Maybe<string>

    providerId_lte

  • Optional providerId_not?: Maybe<string>

    providerId_not

  • Optional providerId_not_contains?: Maybe<string>

    providerId_not_contains

  • Optional providerId_not_ends_with?: Maybe<string>

    providerId_not_ends_with

  • Optional providerId_not_in?: Maybe<Array<string>>

    providerId_not_in

  • Optional providerId_not_starts_with?: Maybe<string>

    providerId_not_starts_with

  • Optional providerId_starts_with?: Maybe<string>

    providerId_starts_with

  • Optional providerType?: Maybe<ProviderType>

    providerType

  • Optional providerType_in?: Maybe<Array<ProviderType>>

    providerType_in

  • Optional providerType_not?: Maybe<ProviderType>

    providerType_not

  • Optional providerType_not_in?: Maybe<Array<ProviderType>>

    providerType_not_in

  • Optional team?: Maybe<_TeamFilter>

    team

  • Optional team_in?: Maybe<_TeamFilter>

    team_in

  • Optional team_not?: Maybe<_TeamFilter>

    team_not

  • Optional team_not_in?: Maybe<_TeamFilter>

    team_not_in

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

_StageFilter

_StageFilter: object

Filter Input Type for Stage

Type declaration

  • Optional AND?: Maybe<Array<_StageFilter>>

    AND

  • Optional OR?: Maybe<Array<_StageFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional jobs?: Maybe<_JobFilter>

    jobs

  • Optional jobs_every?: Maybe<_JobFilter>

    jobs_every

  • Optional jobs_in?: Maybe<_JobFilter>

    jobs_in

  • Optional jobs_none?: Maybe<_JobFilter>

    jobs_none

  • Optional jobs_not?: Maybe<_JobFilter>

    jobs_not

  • Optional jobs_not_in?: Maybe<_JobFilter>

    jobs_not_in

  • Optional jobs_single?: Maybe<_JobFilter>

    jobs_single

  • Optional jobs_some?: Maybe<_JobFilter>

    jobs_some

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional pipeline?: Maybe<_PipelineFilter>

    pipeline

  • Optional pipeline_in?: Maybe<_PipelineFilter>

    pipeline_in

  • Optional pipeline_not?: Maybe<_PipelineFilter>

    pipeline_not

  • Optional pipeline_not_in?: Maybe<_PipelineFilter>

    pipeline_not_in

_StatusFilter

_StatusFilter: object

Filter Input Type for Status

Type declaration

  • Optional AND?: Maybe<Array<_StatusFilter>>

    AND

  • Optional OR?: Maybe<Array<_StatusFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional context?: Maybe<string>

    context

  • Optional context_contains?: Maybe<string>

    context_contains

  • Optional context_ends_with?: Maybe<string>

    context_ends_with

  • Optional context_gt?: Maybe<string>

    context_gt

  • Optional context_gte?: Maybe<string>

    context_gte

  • Optional context_in?: Maybe<Array<string>>

    context_in

  • Optional context_lt?: Maybe<string>

    context_lt

  • Optional context_lte?: Maybe<string>

    context_lte

  • Optional context_not?: Maybe<string>

    context_not

  • Optional context_not_contains?: Maybe<string>

    context_not_contains

  • Optional context_not_ends_with?: Maybe<string>

    context_not_ends_with

  • Optional context_not_in?: Maybe<Array<string>>

    context_not_in

  • Optional context_not_starts_with?: Maybe<string>

    context_not_starts_with

  • Optional context_starts_with?: Maybe<string>

    context_starts_with

  • Optional description?: Maybe<string>

    description

  • Optional description_contains?: Maybe<string>

    description_contains

  • Optional description_ends_with?: Maybe<string>

    description_ends_with

  • Optional description_gt?: Maybe<string>

    description_gt

  • Optional description_gte?: Maybe<string>

    description_gte

  • Optional description_in?: Maybe<Array<string>>

    description_in

  • Optional description_lt?: Maybe<string>

    description_lt

  • Optional description_lte?: Maybe<string>

    description_lte

  • Optional description_not?: Maybe<string>

    description_not

  • Optional description_not_contains?: Maybe<string>

    description_not_contains

  • Optional description_not_ends_with?: Maybe<string>

    description_not_ends_with

  • Optional description_not_in?: Maybe<Array<string>>

    description_not_in

  • Optional description_not_starts_with?: Maybe<string>

    description_not_starts_with

  • Optional description_starts_with?: Maybe<string>

    description_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional state?: Maybe<StatusState>

    state

  • Optional state_in?: Maybe<Array<StatusState>>

    state_in

  • Optional state_not?: Maybe<StatusState>

    state_not

  • Optional state_not_in?: Maybe<Array<StatusState>>

    state_not_in

  • Optional targetUrl?: Maybe<string>

    targetUrl

  • Optional targetUrl_contains?: Maybe<string>

    targetUrl_contains

  • Optional targetUrl_ends_with?: Maybe<string>

    targetUrl_ends_with

  • Optional targetUrl_gt?: Maybe<string>

    targetUrl_gt

  • Optional targetUrl_gte?: Maybe<string>

    targetUrl_gte

  • Optional targetUrl_in?: Maybe<Array<string>>

    targetUrl_in

  • Optional targetUrl_lt?: Maybe<string>

    targetUrl_lt

  • Optional targetUrl_lte?: Maybe<string>

    targetUrl_lte

  • Optional targetUrl_not?: Maybe<string>

    targetUrl_not

  • Optional targetUrl_not_contains?: Maybe<string>

    targetUrl_not_contains

  • Optional targetUrl_not_ends_with?: Maybe<string>

    targetUrl_not_ends_with

  • Optional targetUrl_not_in?: Maybe<Array<string>>

    targetUrl_not_in

  • Optional targetUrl_not_starts_with?: Maybe<string>

    targetUrl_not_starts_with

  • Optional targetUrl_starts_with?: Maybe<string>

    targetUrl_starts_with

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_TagFilter

_TagFilter: object

Filter Input Type for Tag

Type declaration

  • Optional AND?: Maybe<Array<_TagFilter>>

    AND

  • Optional OR?: Maybe<Array<_TagFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional builds?: Maybe<_BuildFilter>

    builds

  • Optional builds_every?: Maybe<_BuildFilter>

    builds_every

  • Optional builds_in?: Maybe<_BuildFilter>

    builds_in

  • Optional builds_none?: Maybe<_BuildFilter>

    builds_none

  • Optional builds_not?: Maybe<_BuildFilter>

    builds_not

  • Optional builds_not_in?: Maybe<_BuildFilter>

    builds_not_in

  • Optional builds_single?: Maybe<_BuildFilter>

    builds_single

  • Optional builds_some?: Maybe<_BuildFilter>

    builds_some

  • Optional commit?: Maybe<_CommitFilter>

    commit

  • Optional commit_in?: Maybe<_CommitFilter>

    commit_in

  • Optional commit_not?: Maybe<_CommitFilter>

    commit_not

  • Optional commit_not_in?: Maybe<_CommitFilter>

    commit_not_in

  • Optional containers?: Maybe<_DockerImageFilter>

    containers

  • Optional containers_every?: Maybe<_DockerImageFilter>

    containers_every

  • Optional containers_in?: Maybe<_DockerImageFilter>

    containers_in

  • Optional containers_none?: Maybe<_DockerImageFilter>

    containers_none

  • Optional containers_not?: Maybe<_DockerImageFilter>

    containers_not

  • Optional containers_not_in?: Maybe<_DockerImageFilter>

    containers_not_in

  • Optional containers_single?: Maybe<_DockerImageFilter>

    containers_single

  • Optional containers_some?: Maybe<_DockerImageFilter>

    containers_some

  • Optional description?: Maybe<string>

    description

  • Optional description_contains?: Maybe<string>

    description_contains

  • Optional description_ends_with?: Maybe<string>

    description_ends_with

  • Optional description_gt?: Maybe<string>

    description_gt

  • Optional description_gte?: Maybe<string>

    description_gte

  • Optional description_in?: Maybe<Array<string>>

    description_in

  • Optional description_lt?: Maybe<string>

    description_lt

  • Optional description_lte?: Maybe<string>

    description_lte

  • Optional description_not?: Maybe<string>

    description_not

  • Optional description_not_contains?: Maybe<string>

    description_not_contains

  • Optional description_not_ends_with?: Maybe<string>

    description_not_ends_with

  • Optional description_not_in?: Maybe<Array<string>>

    description_not_in

  • Optional description_not_starts_with?: Maybe<string>

    description_not_starts_with

  • Optional description_starts_with?: Maybe<string>

    description_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional ref?: Maybe<string>

    ref

  • Optional ref_contains?: Maybe<string>

    ref_contains

  • Optional ref_ends_with?: Maybe<string>

    ref_ends_with

  • Optional ref_gt?: Maybe<string>

    ref_gt

  • Optional ref_gte?: Maybe<string>

    ref_gte

  • Optional ref_in?: Maybe<Array<string>>

    ref_in

  • Optional ref_lt?: Maybe<string>

    ref_lt

  • Optional ref_lte?: Maybe<string>

    ref_lte

  • Optional ref_not?: Maybe<string>

    ref_not

  • Optional ref_not_contains?: Maybe<string>

    ref_not_contains

  • Optional ref_not_ends_with?: Maybe<string>

    ref_not_ends_with

  • Optional ref_not_in?: Maybe<Array<string>>

    ref_not_in

  • Optional ref_not_starts_with?: Maybe<string>

    ref_not_starts_with

  • Optional ref_starts_with?: Maybe<string>

    ref_starts_with

  • Optional release?: Maybe<_ReleaseFilter>

    release

  • Optional release_in?: Maybe<_ReleaseFilter>

    release_in

  • Optional release_not?: Maybe<_ReleaseFilter>

    release_not

  • Optional release_not_in?: Maybe<_ReleaseFilter>

    release_not_in

  • Optional timestamp?: Maybe<string>

    timestamp

  • Optional timestamp_contains?: Maybe<string>

    timestamp_contains

  • Optional timestamp_ends_with?: Maybe<string>

    timestamp_ends_with

  • Optional timestamp_gt?: Maybe<string>

    timestamp_gt

  • Optional timestamp_gte?: Maybe<string>

    timestamp_gte

  • Optional timestamp_in?: Maybe<Array<string>>

    timestamp_in

  • Optional timestamp_lt?: Maybe<string>

    timestamp_lt

  • Optional timestamp_lte?: Maybe<string>

    timestamp_lte

  • Optional timestamp_not?: Maybe<string>

    timestamp_not

  • Optional timestamp_not_contains?: Maybe<string>

    timestamp_not_contains

  • Optional timestamp_not_ends_with?: Maybe<string>

    timestamp_not_ends_with

  • Optional timestamp_not_in?: Maybe<Array<string>>

    timestamp_not_in

  • Optional timestamp_not_starts_with?: Maybe<string>

    timestamp_not_starts_with

  • Optional timestamp_starts_with?: Maybe<string>

    timestamp_starts_with

_TeamFilter

_TeamFilter: object

Filter Input Type for Team

Type declaration

  • Optional AND?: Maybe<Array<_TeamFilter>>

    AND

  • Optional OR?: Maybe<Array<_TeamFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional chatTeams?: Maybe<_ChatTeamFilter>

    chatTeams

  • Optional chatTeams_every?: Maybe<_ChatTeamFilter>

    chatTeams_every

  • Optional chatTeams_in?: Maybe<_ChatTeamFilter>

    chatTeams_in

  • Optional chatTeams_none?: Maybe<_ChatTeamFilter>

    chatTeams_none

  • Optional chatTeams_not?: Maybe<_ChatTeamFilter>

    chatTeams_not

  • Optional chatTeams_not_in?: Maybe<_ChatTeamFilter>

    chatTeams_not_in

  • Optional chatTeams_single?: Maybe<_ChatTeamFilter>

    chatTeams_single

  • Optional chatTeams_some?: Maybe<_ChatTeamFilter>

    chatTeams_some

  • Optional createdAt?: Maybe<string>

    createdAt

  • Optional createdAt_contains?: Maybe<string>

    createdAt_contains

  • Optional createdAt_ends_with?: Maybe<string>

    createdAt_ends_with

  • Optional createdAt_gt?: Maybe<string>

    createdAt_gt

  • Optional createdAt_gte?: Maybe<string>

    createdAt_gte

  • Optional createdAt_in?: Maybe<Array<string>>

    createdAt_in

  • Optional createdAt_lt?: Maybe<string>

    createdAt_lt

  • Optional createdAt_lte?: Maybe<string>

    createdAt_lte

  • Optional createdAt_not?: Maybe<string>

    createdAt_not

  • Optional createdAt_not_contains?: Maybe<string>

    createdAt_not_contains

  • Optional createdAt_not_ends_with?: Maybe<string>

    createdAt_not_ends_with

  • Optional createdAt_not_in?: Maybe<Array<string>>

    createdAt_not_in

  • Optional createdAt_not_starts_with?: Maybe<string>

    createdAt_not_starts_with

  • Optional createdAt_starts_with?: Maybe<string>

    createdAt_starts_with

  • Optional description?: Maybe<string>

    description

  • Optional description_contains?: Maybe<string>

    description_contains

  • Optional description_ends_with?: Maybe<string>

    description_ends_with

  • Optional description_gt?: Maybe<string>

    description_gt

  • Optional description_gte?: Maybe<string>

    description_gte

  • Optional description_in?: Maybe<Array<string>>

    description_in

  • Optional description_lt?: Maybe<string>

    description_lt

  • Optional description_lte?: Maybe<string>

    description_lte

  • Optional description_not?: Maybe<string>

    description_not

  • Optional description_not_contains?: Maybe<string>

    description_not_contains

  • Optional description_not_ends_with?: Maybe<string>

    description_not_ends_with

  • Optional description_not_in?: Maybe<Array<string>>

    description_not_in

  • Optional description_not_starts_with?: Maybe<string>

    description_not_starts_with

  • Optional description_starts_with?: Maybe<string>

    description_starts_with

  • Optional iconUrl?: Maybe<string>

    iconUrl

  • Optional iconUrl_contains?: Maybe<string>

    iconUrl_contains

  • Optional iconUrl_ends_with?: Maybe<string>

    iconUrl_ends_with

  • Optional iconUrl_gt?: Maybe<string>

    iconUrl_gt

  • Optional iconUrl_gte?: Maybe<string>

    iconUrl_gte

  • Optional iconUrl_in?: Maybe<Array<string>>

    iconUrl_in

  • Optional iconUrl_lt?: Maybe<string>

    iconUrl_lt

  • Optional iconUrl_lte?: Maybe<string>

    iconUrl_lte

  • Optional iconUrl_not?: Maybe<string>

    iconUrl_not

  • Optional iconUrl_not_contains?: Maybe<string>

    iconUrl_not_contains

  • Optional iconUrl_not_ends_with?: Maybe<string>

    iconUrl_not_ends_with

  • Optional iconUrl_not_in?: Maybe<Array<string>>

    iconUrl_not_in

  • Optional iconUrl_not_starts_with?: Maybe<string>

    iconUrl_not_starts_with

  • Optional iconUrl_starts_with?: Maybe<string>

    iconUrl_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional orgs?: Maybe<_OrgFilter>

    orgs

  • Optional orgs_every?: Maybe<_OrgFilter>

    orgs_every

  • Optional orgs_in?: Maybe<_OrgFilter>

    orgs_in

  • Optional orgs_none?: Maybe<_OrgFilter>

    orgs_none

  • Optional orgs_not?: Maybe<_OrgFilter>

    orgs_not

  • Optional orgs_not_in?: Maybe<_OrgFilter>

    orgs_not_in

  • Optional orgs_single?: Maybe<_OrgFilter>

    orgs_single

  • Optional orgs_some?: Maybe<_OrgFilter>

    orgs_some

  • Optional persons?: Maybe<_PersonFilter>

    persons

  • Optional persons_every?: Maybe<_PersonFilter>

    persons_every

  • Optional persons_in?: Maybe<_PersonFilter>

    persons_in

  • Optional persons_none?: Maybe<_PersonFilter>

    persons_none

  • Optional persons_not?: Maybe<_PersonFilter>

    persons_not

  • Optional persons_not_in?: Maybe<_PersonFilter>

    persons_not_in

  • Optional persons_single?: Maybe<_PersonFilter>

    persons_single

  • Optional persons_some?: Maybe<_PersonFilter>

    persons_some

  • Optional providers?: Maybe<_GitHubProviderFilter>

    providers

  • Optional providers_every?: Maybe<_GitHubProviderFilter>

    providers_every

  • Optional providers_in?: Maybe<_GitHubProviderFilter>

    providers_in

  • Optional providers_none?: Maybe<_GitHubProviderFilter>

    providers_none

  • Optional providers_not?: Maybe<_GitHubProviderFilter>

    providers_not

  • Optional providers_not_in?: Maybe<_GitHubProviderFilter>

    providers_not_in

  • Optional providers_single?: Maybe<_GitHubProviderFilter>

    providers_single

  • Optional providers_some?: Maybe<_GitHubProviderFilter>

    providers_some

  • Optional scmProviders?: Maybe<_ScmProviderFilter>

    scmProviders

  • Optional scmProviders_every?: Maybe<_ScmProviderFilter>

    scmProviders_every

  • Optional scmProviders_in?: Maybe<_ScmProviderFilter>

    scmProviders_in

  • Optional scmProviders_none?: Maybe<_ScmProviderFilter>

    scmProviders_none

  • Optional scmProviders_not?: Maybe<_ScmProviderFilter>

    scmProviders_not

  • Optional scmProviders_not_in?: Maybe<_ScmProviderFilter>

    scmProviders_not_in

  • Optional scmProviders_single?: Maybe<_ScmProviderFilter>

    scmProviders_single

  • Optional scmProviders_some?: Maybe<_ScmProviderFilter>

    scmProviders_some

_UserJoinedChannelFilter

_UserJoinedChannelFilter: object

Filter Input Type for UserJoinedChannel

Type declaration

  • Optional AND?: Maybe<Array<_UserJoinedChannelFilter>>

    AND

  • Optional OR?: Maybe<Array<_UserJoinedChannelFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional channel?: Maybe<_ChatChannelFilter>

    channel

  • Optional channel_in?: Maybe<_ChatChannelFilter>

    channel_in

  • Optional channel_not?: Maybe<_ChatChannelFilter>

    channel_not

  • Optional channel_not_in?: Maybe<_ChatChannelFilter>

    channel_not_in

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional user?: Maybe<_ChatIdFilter>

    user

  • Optional user_in?: Maybe<_ChatIdFilter>

    user_in

  • Optional user_not?: Maybe<_ChatIdFilter>

    user_not

  • Optional user_not_in?: Maybe<_ChatIdFilter>

    user_not_in

_WebhookFilter

_WebhookFilter: object

Filter Input Type for Webhook

Type declaration

  • Optional AND?: Maybe<Array<_WebhookFilter>>

    AND

  • Optional OR?: Maybe<Array<_WebhookFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional org?: Maybe<_OrgFilter>

    org

  • Optional org_in?: Maybe<_OrgFilter>

    org_in

  • Optional org_not?: Maybe<_OrgFilter>

    org_not

  • Optional org_not_in?: Maybe<_OrgFilter>

    org_not_in

  • Optional repo?: Maybe<_RepoFilter>

    repo

  • Optional repo_in?: Maybe<_RepoFilter>

    repo_in

  • Optional repo_not?: Maybe<_RepoFilter>

    repo_not

  • Optional repo_not_in?: Maybe<_RepoFilter>

    repo_not_in

  • Optional url?: Maybe<string>

    url

  • Optional url_contains?: Maybe<string>

    url_contains

  • Optional url_ends_with?: Maybe<string>

    url_ends_with

  • Optional url_gt?: Maybe<string>

    url_gt

  • Optional url_gte?: Maybe<string>

    url_gte

  • Optional url_in?: Maybe<Array<string>>

    url_in

  • Optional url_lt?: Maybe<string>

    url_lt

  • Optional url_lte?: Maybe<string>

    url_lte

  • Optional url_not?: Maybe<string>

    url_not

  • Optional url_not_contains?: Maybe<string>

    url_not_contains

  • Optional url_not_ends_with?: Maybe<string>

    url_not_ends_with

  • Optional url_not_in?: Maybe<Array<string>>

    url_not_in

  • Optional url_not_starts_with?: Maybe<string>

    url_not_starts_with

  • Optional url_starts_with?: Maybe<string>

    url_starts_with

  • Optional webhookType?: Maybe<WebhookType>

    webhookType

  • Optional webhookType_in?: Maybe<Array<WebhookType>>

    webhookType_in

  • Optional webhookType_not?: Maybe<WebhookType>

    webhookType_not

  • Optional webhookType_not_in?: Maybe<Array<WebhookType>>

    webhookType_not_in

_WorkflowFilter

_WorkflowFilter: object

Filter Input Type for Workflow

Type declaration

  • Optional AND?: Maybe<Array<_WorkflowFilter>>

    AND

  • Optional OR?: Maybe<Array<_WorkflowFilter>>

    OR

  • Optional atmTeamId?: Maybe<string>

    atmTeamId

  • Optional atmTeamId_contains?: Maybe<string>

    atmTeamId_contains

  • Optional atmTeamId_ends_with?: Maybe<string>

    atmTeamId_ends_with

  • Optional atmTeamId_gt?: Maybe<string>

    atmTeamId_gt

  • Optional atmTeamId_gte?: Maybe<string>

    atmTeamId_gte

  • Optional atmTeamId_in?: Maybe<Array<string>>

    atmTeamId_in

  • Optional atmTeamId_lt?: Maybe<string>

    atmTeamId_lt

  • Optional atmTeamId_lte?: Maybe<string>

    atmTeamId_lte

  • Optional atmTeamId_not?: Maybe<string>

    atmTeamId_not

  • Optional atmTeamId_not_contains?: Maybe<string>

    atmTeamId_not_contains

  • Optional atmTeamId_not_ends_with?: Maybe<string>

    atmTeamId_not_ends_with

  • Optional atmTeamId_not_in?: Maybe<Array<string>>

    atmTeamId_not_in

  • Optional atmTeamId_not_starts_with?: Maybe<string>

    atmTeamId_not_starts_with

  • Optional atmTeamId_starts_with?: Maybe<string>

    atmTeamId_starts_with

  • Optional builds?: Maybe<_BuildFilter>

    builds

  • Optional builds_every?: Maybe<_BuildFilter>

    builds_every

  • Optional builds_in?: Maybe<_BuildFilter>

    builds_in

  • Optional builds_none?: Maybe<_BuildFilter>

    builds_none

  • Optional builds_not?: Maybe<_BuildFilter>

    builds_not

  • Optional builds_not_in?: Maybe<_BuildFilter>

    builds_not_in

  • Optional builds_single?: Maybe<_BuildFilter>

    builds_single

  • Optional builds_some?: Maybe<_BuildFilter>

    builds_some

  • Optional config?: Maybe<string>

    config

  • Optional config_contains?: Maybe<string>

    config_contains

  • Optional config_ends_with?: Maybe<string>

    config_ends_with

  • Optional config_gt?: Maybe<string>

    config_gt

  • Optional config_gte?: Maybe<string>

    config_gte

  • Optional config_in?: Maybe<Array<string>>

    config_in

  • Optional config_lt?: Maybe<string>

    config_lt

  • Optional config_lte?: Maybe<string>

    config_lte

  • Optional config_not?: Maybe<string>

    config_not

  • Optional config_not_contains?: Maybe<string>

    config_not_contains

  • Optional config_not_ends_with?: Maybe<string>

    config_not_ends_with

  • Optional config_not_in?: Maybe<Array<string>>

    config_not_in

  • Optional config_not_starts_with?: Maybe<string>

    config_not_starts_with

  • Optional config_starts_with?: Maybe<string>

    config_starts_with

  • Optional id?: Maybe<string>

    id

  • Optional id_contains?: Maybe<string>

    id_contains

  • Optional id_ends_with?: Maybe<string>

    id_ends_with

  • Optional id_gt?: Maybe<string>

    id_gt

  • Optional id_gte?: Maybe<string>

    id_gte

  • Optional id_in?: Maybe<Array<string>>

    id_in

  • Optional id_lt?: Maybe<string>

    id_lt

  • Optional id_lte?: Maybe<string>

    id_lte

  • Optional id_not?: Maybe<string>

    id_not

  • Optional id_not_contains?: Maybe<string>

    id_not_contains

  • Optional id_not_ends_with?: Maybe<string>

    id_not_ends_with

  • Optional id_not_in?: Maybe<Array<string>>

    id_not_in

  • Optional id_not_starts_with?: Maybe<string>

    id_not_starts_with

  • Optional id_starts_with?: Maybe<string>

    id_starts_with

  • Optional name?: Maybe<string>

    name

  • Optional name_contains?: Maybe<string>

    name_contains

  • Optional name_ends_with?: Maybe<string>

    name_ends_with

  • Optional name_gt?: Maybe<string>

    name_gt

  • Optional name_gte?: Maybe<string>

    name_gte

  • Optional name_in?: Maybe<Array<string>>

    name_in

  • Optional name_lt?: Maybe<string>

    name_lt

  • Optional name_lte?: Maybe<string>

    name_lte

  • Optional name_not?: Maybe<string>

    name_not

  • Optional name_not_contains?: Maybe<string>

    name_not_contains

  • Optional name_not_ends_with?: Maybe<string>

    name_not_ends_with

  • Optional name_not_in?: Maybe<Array<string>>

    name_not_in

  • Optional name_not_starts_with?: Maybe<string>

    name_not_starts_with

  • Optional name_starts_with?: Maybe<string>

    name_starts_with

  • Optional provider?: Maybe<string>

    provider

  • Optional provider_contains?: Maybe<string>

    provider_contains

  • Optional provider_ends_with?: Maybe<string>

    provider_ends_with

  • Optional provider_gt?: Maybe<string>

    provider_gt

  • Optional provider_gte?: Maybe<string>

    provider_gte

  • Optional provider_in?: Maybe<Array<string>>

    provider_in

  • Optional provider_lt?: Maybe<string>

    provider_lt

  • Optional provider_lte?: Maybe<string>

    provider_lte

  • Optional provider_not?: Maybe<string>

    provider_not

  • Optional provider_not_contains?: Maybe<string>

    provider_not_contains

  • Optional provider_not_ends_with?: Maybe<string>

    provider_not_ends_with

  • Optional provider_not_in?: Maybe<Array<string>>

    provider_not_in

  • Optional provider_not_starts_with?: Maybe<string>

    provider_not_starts_with

  • Optional provider_starts_with?: Maybe<string>

    provider_starts_with

  • Optional workflowId?: Maybe<string>

    workflowId

  • Optional workflowId_contains?: Maybe<string>

    workflowId_contains

  • Optional workflowId_ends_with?: Maybe<string>

    workflowId_ends_with

  • Optional workflowId_gt?: Maybe<string>

    workflowId_gt

  • Optional workflowId_gte?: Maybe<string>

    workflowId_gte

  • Optional workflowId_in?: Maybe<Array<string>>

    workflowId_in

  • Optional workflowId_lt?: Maybe<string>

    workflowId_lt

  • Optional workflowId_lte?: Maybe<string>

    workflowId_lte

  • Optional workflowId_not?: Maybe<string>

    workflowId_not

  • Optional workflowId_not_contains?: Maybe<string>

    workflowId_not_contains

  • Optional workflowId_not_ends_with?: Maybe<string>

    workflowId_not_ends_with

  • Optional workflowId_not_in?: Maybe<Array<string>>

    workflowId_not_in

  • Optional workflowId_not_starts_with?: Maybe<string>

    workflowId_not_starts_with

  • Optional workflowId_starts_with?: Maybe<string>

    workflowId_starts_with

Generated using TypeDoc